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		ID      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		History        func(childComplexity int) int
   90		ID             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		ID      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		History        func(childComplexity int) int
  191		ID             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		ID      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		Name        func(childComplexity int) int
  214	}
  215
  216	IdentityConnection struct {
  217		Edges      func(childComplexity int) int
  218		Nodes      func(childComplexity int) int
  219		PageInfo   func(childComplexity int) int
  220		TotalCount func(childComplexity int) int
  221	}
  222
  223	IdentityEdge struct {
  224		Cursor func(childComplexity int) int
  225		Node   func(childComplexity int) int
  226	}
  227
  228	Label struct {
  229		Color func(childComplexity int) int
  230		Name  func(childComplexity int) int
  231	}
  232
  233	LabelChangeOperation struct {
  234		Added   func(childComplexity int) int
  235		Author  func(childComplexity int) int
  236		Date    func(childComplexity int) int
  237		ID      func(childComplexity int) int
  238		Removed func(childComplexity int) int
  239	}
  240
  241	LabelChangeResult struct {
  242		Label  func(childComplexity int) int
  243		Status func(childComplexity int) int
  244	}
  245
  246	LabelChangeTimelineItem struct {
  247		Added   func(childComplexity int) int
  248		Author  func(childComplexity int) int
  249		Date    func(childComplexity int) int
  250		ID      func(childComplexity int) int
  251		Removed func(childComplexity int) int
  252	}
  253
  254	LabelConnection struct {
  255		Edges      func(childComplexity int) int
  256		Nodes      func(childComplexity int) int
  257		PageInfo   func(childComplexity int) int
  258		TotalCount func(childComplexity int) int
  259	}
  260
  261	LabelEdge struct {
  262		Cursor func(childComplexity int) int
  263		Node   func(childComplexity int) int
  264	}
  265
  266	Mutation struct {
  267		AddComment     func(childComplexity int, input models.AddCommentInput) int
  268		ChangeLabels   func(childComplexity int, input *models.ChangeLabelInput) int
  269		CloseBug       func(childComplexity int, input models.CloseBugInput) int
  270		Commit         func(childComplexity int, input models.CommitInput) int
  271		CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
  272		NewBug         func(childComplexity int, input models.NewBugInput) int
  273		OpenBug        func(childComplexity int, input models.OpenBugInput) int
  274		SetTitle       func(childComplexity int, input models.SetTitleInput) int
  275	}
  276
  277	NewBugPayload struct {
  278		Bug              func(childComplexity int) int
  279		ClientMutationID func(childComplexity int) int
  280		Operation        func(childComplexity int) int
  281	}
  282
  283	OpenBugPayload struct {
  284		Bug              func(childComplexity int) int
  285		ClientMutationID func(childComplexity int) int
  286		Operation        func(childComplexity int) int
  287	}
  288
  289	OperationConnection struct {
  290		Edges      func(childComplexity int) int
  291		Nodes      func(childComplexity int) int
  292		PageInfo   func(childComplexity int) int
  293		TotalCount func(childComplexity int) int
  294	}
  295
  296	OperationEdge struct {
  297		Cursor func(childComplexity int) int
  298		Node   func(childComplexity int) int
  299	}
  300
  301	PageInfo struct {
  302		EndCursor       func(childComplexity int) int
  303		HasNextPage     func(childComplexity int) int
  304		HasPreviousPage func(childComplexity int) int
  305		StartCursor     func(childComplexity int) int
  306	}
  307
  308	Query struct {
  309		DefaultRepository func(childComplexity int) int
  310		Repository        func(childComplexity int, ref string) int
  311	}
  312
  313	Repository struct {
  314		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  315		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  316		Bug           func(childComplexity int, prefix string) int
  317		Identity      func(childComplexity int, prefix string) int
  318		UserIdentity  func(childComplexity int) int
  319		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  320	}
  321
  322	SetStatusOperation struct {
  323		Author func(childComplexity int) int
  324		Date   func(childComplexity int) int
  325		ID     func(childComplexity int) int
  326		Status func(childComplexity int) int
  327	}
  328
  329	SetStatusTimelineItem struct {
  330		Author func(childComplexity int) int
  331		Date   func(childComplexity int) int
  332		ID     func(childComplexity int) int
  333		Status func(childComplexity int) int
  334	}
  335
  336	SetTitleOperation struct {
  337		Author func(childComplexity int) int
  338		Date   func(childComplexity int) int
  339		ID     func(childComplexity int) int
  340		Title  func(childComplexity int) int
  341		Was    func(childComplexity int) int
  342	}
  343
  344	SetTitlePayload struct {
  345		Bug              func(childComplexity int) int
  346		ClientMutationID func(childComplexity int) int
  347		Operation        func(childComplexity int) int
  348	}
  349
  350	SetTitleTimelineItem struct {
  351		Author func(childComplexity int) int
  352		Date   func(childComplexity int) int
  353		ID     func(childComplexity int) int
  354		Title  func(childComplexity int) int
  355		Was    func(childComplexity int) int
  356	}
  357
  358	TimelineItemConnection struct {
  359		Edges      func(childComplexity int) int
  360		Nodes      func(childComplexity int) int
  361		PageInfo   func(childComplexity int) int
  362		TotalCount func(childComplexity int) int
  363	}
  364
  365	TimelineItemEdge struct {
  366		Cursor func(childComplexity int) int
  367		Node   func(childComplexity int) int
  368	}
  369}
  370
  371type AddCommentOperationResolver interface {
  372	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  373
  374	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  375}
  376type AddCommentTimelineItemResolver interface {
  377	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  378
  379	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  380	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  381}
  382type BugResolver interface {
  383	ID(ctx context.Context, obj *bug.Snapshot) (string, error)
  384	HumanID(ctx context.Context, obj *bug.Snapshot) (string, error)
  385	Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
  386
  387	LastEdit(ctx context.Context, obj *bug.Snapshot) (*time.Time, error)
  388	Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  389	Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  390	Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  391	Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  392	Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  393}
  394type ColorResolver interface {
  395	R(ctx context.Context, obj *color.RGBA) (int, error)
  396	G(ctx context.Context, obj *color.RGBA) (int, error)
  397	B(ctx context.Context, obj *color.RGBA) (int, error)
  398}
  399type CommentHistoryStepResolver interface {
  400	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  401}
  402type CreateOperationResolver interface {
  403	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  404
  405	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  406}
  407type CreateTimelineItemResolver interface {
  408	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  409
  410	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  411	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  412}
  413type EditCommentOperationResolver interface {
  414	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  415
  416	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  417	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  418}
  419type IdentityResolver interface {
  420	ID(ctx context.Context, obj identity.Interface) (string, error)
  421	HumanID(ctx context.Context, obj identity.Interface) (string, error)
  422}
  423type LabelResolver interface {
  424	Name(ctx context.Context, obj *bug.Label) (string, error)
  425	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  426}
  427type LabelChangeOperationResolver interface {
  428	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  429
  430	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  431}
  432type LabelChangeResultResolver interface {
  433	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  434}
  435type LabelChangeTimelineItemResolver interface {
  436	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  437
  438	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  439}
  440type MutationResolver interface {
  441	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  442	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  443	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  444	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  445	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  446	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  447	Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
  448	CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
  449}
  450type QueryResolver interface {
  451	DefaultRepository(ctx context.Context) (*models.Repository, error)
  452	Repository(ctx context.Context, ref string) (*models.Repository, error)
  453}
  454type RepositoryResolver interface {
  455	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  456	Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
  457	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  458	Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
  459	UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
  460	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  461}
  462type SetStatusOperationResolver interface {
  463	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  464
  465	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  466	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  467}
  468type SetStatusTimelineItemResolver interface {
  469	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  470
  471	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  472	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  473}
  474type SetTitleOperationResolver interface {
  475	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  476
  477	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  478}
  479type SetTitleTimelineItemResolver interface {
  480	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  481
  482	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  483}
  484
  485type executableSchema struct {
  486	resolvers  ResolverRoot
  487	directives DirectiveRoot
  488	complexity ComplexityRoot
  489}
  490
  491func (e *executableSchema) Schema() *ast.Schema {
  492	return parsedSchema
  493}
  494
  495func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  496	ec := executionContext{nil, e}
  497	_ = ec
  498	switch typeName + "." + field {
  499
  500	case "AddCommentOperation.author":
  501		if e.complexity.AddCommentOperation.Author == nil {
  502			break
  503		}
  504
  505		return e.complexity.AddCommentOperation.Author(childComplexity), true
  506
  507	case "AddCommentOperation.date":
  508		if e.complexity.AddCommentOperation.Date == nil {
  509			break
  510		}
  511
  512		return e.complexity.AddCommentOperation.Date(childComplexity), true
  513
  514	case "AddCommentOperation.files":
  515		if e.complexity.AddCommentOperation.Files == nil {
  516			break
  517		}
  518
  519		return e.complexity.AddCommentOperation.Files(childComplexity), true
  520
  521	case "AddCommentOperation.id":
  522		if e.complexity.AddCommentOperation.ID == nil {
  523			break
  524		}
  525
  526		return e.complexity.AddCommentOperation.ID(childComplexity), true
  527
  528	case "AddCommentOperation.message":
  529		if e.complexity.AddCommentOperation.Message == nil {
  530			break
  531		}
  532
  533		return e.complexity.AddCommentOperation.Message(childComplexity), true
  534
  535	case "AddCommentPayload.bug":
  536		if e.complexity.AddCommentPayload.Bug == nil {
  537			break
  538		}
  539
  540		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  541
  542	case "AddCommentPayload.clientMutationId":
  543		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  544			break
  545		}
  546
  547		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  548
  549	case "AddCommentPayload.operation":
  550		if e.complexity.AddCommentPayload.Operation == nil {
  551			break
  552		}
  553
  554		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  555
  556	case "AddCommentTimelineItem.author":
  557		if e.complexity.AddCommentTimelineItem.Author == nil {
  558			break
  559		}
  560
  561		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  562
  563	case "AddCommentTimelineItem.createdAt":
  564		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  565			break
  566		}
  567
  568		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  569
  570	case "AddCommentTimelineItem.edited":
  571		if e.complexity.AddCommentTimelineItem.Edited == nil {
  572			break
  573		}
  574
  575		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  576
  577	case "AddCommentTimelineItem.files":
  578		if e.complexity.AddCommentTimelineItem.Files == nil {
  579			break
  580		}
  581
  582		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  583
  584	case "AddCommentTimelineItem.history":
  585		if e.complexity.AddCommentTimelineItem.History == nil {
  586			break
  587		}
  588
  589		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  590
  591	case "AddCommentTimelineItem.id":
  592		if e.complexity.AddCommentTimelineItem.ID == nil {
  593			break
  594		}
  595
  596		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  597
  598	case "AddCommentTimelineItem.lastEdit":
  599		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  600			break
  601		}
  602
  603		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  604
  605	case "AddCommentTimelineItem.message":
  606		if e.complexity.AddCommentTimelineItem.Message == nil {
  607			break
  608		}
  609
  610		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  611
  612	case "AddCommentTimelineItem.messageIsEmpty":
  613		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  614			break
  615		}
  616
  617		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  618
  619	case "Bug.actors":
  620		if e.complexity.Bug.Actors == nil {
  621			break
  622		}
  623
  624		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  625		if err != nil {
  626			return 0, false
  627		}
  628
  629		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  630
  631	case "Bug.author":
  632		if e.complexity.Bug.Author == nil {
  633			break
  634		}
  635
  636		return e.complexity.Bug.Author(childComplexity), true
  637
  638	case "Bug.comments":
  639		if e.complexity.Bug.Comments == nil {
  640			break
  641		}
  642
  643		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  644		if err != nil {
  645			return 0, false
  646		}
  647
  648		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  649
  650	case "Bug.createdAt":
  651		if e.complexity.Bug.CreatedAt == nil {
  652			break
  653		}
  654
  655		return e.complexity.Bug.CreatedAt(childComplexity), true
  656
  657	case "Bug.humanId":
  658		if e.complexity.Bug.HumanID == nil {
  659			break
  660		}
  661
  662		return e.complexity.Bug.HumanID(childComplexity), true
  663
  664	case "Bug.id":
  665		if e.complexity.Bug.ID == nil {
  666			break
  667		}
  668
  669		return e.complexity.Bug.ID(childComplexity), true
  670
  671	case "Bug.labels":
  672		if e.complexity.Bug.Labels == nil {
  673			break
  674		}
  675
  676		return e.complexity.Bug.Labels(childComplexity), true
  677
  678	case "Bug.lastEdit":
  679		if e.complexity.Bug.LastEdit == nil {
  680			break
  681		}
  682
  683		return e.complexity.Bug.LastEdit(childComplexity), true
  684
  685	case "Bug.operations":
  686		if e.complexity.Bug.Operations == nil {
  687			break
  688		}
  689
  690		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  691		if err != nil {
  692			return 0, false
  693		}
  694
  695		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  696
  697	case "Bug.participants":
  698		if e.complexity.Bug.Participants == nil {
  699			break
  700		}
  701
  702		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  703		if err != nil {
  704			return 0, false
  705		}
  706
  707		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  708
  709	case "Bug.status":
  710		if e.complexity.Bug.Status == nil {
  711			break
  712		}
  713
  714		return e.complexity.Bug.Status(childComplexity), true
  715
  716	case "Bug.timeline":
  717		if e.complexity.Bug.Timeline == nil {
  718			break
  719		}
  720
  721		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  722		if err != nil {
  723			return 0, false
  724		}
  725
  726		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  727
  728	case "Bug.title":
  729		if e.complexity.Bug.Title == nil {
  730			break
  731		}
  732
  733		return e.complexity.Bug.Title(childComplexity), true
  734
  735	case "BugConnection.edges":
  736		if e.complexity.BugConnection.Edges == nil {
  737			break
  738		}
  739
  740		return e.complexity.BugConnection.Edges(childComplexity), true
  741
  742	case "BugConnection.nodes":
  743		if e.complexity.BugConnection.Nodes == nil {
  744			break
  745		}
  746
  747		return e.complexity.BugConnection.Nodes(childComplexity), true
  748
  749	case "BugConnection.pageInfo":
  750		if e.complexity.BugConnection.PageInfo == nil {
  751			break
  752		}
  753
  754		return e.complexity.BugConnection.PageInfo(childComplexity), true
  755
  756	case "BugConnection.totalCount":
  757		if e.complexity.BugConnection.TotalCount == nil {
  758			break
  759		}
  760
  761		return e.complexity.BugConnection.TotalCount(childComplexity), true
  762
  763	case "BugEdge.cursor":
  764		if e.complexity.BugEdge.Cursor == nil {
  765			break
  766		}
  767
  768		return e.complexity.BugEdge.Cursor(childComplexity), true
  769
  770	case "BugEdge.node":
  771		if e.complexity.BugEdge.Node == nil {
  772			break
  773		}
  774
  775		return e.complexity.BugEdge.Node(childComplexity), true
  776
  777	case "ChangeLabelPayload.bug":
  778		if e.complexity.ChangeLabelPayload.Bug == nil {
  779			break
  780		}
  781
  782		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  783
  784	case "ChangeLabelPayload.clientMutationId":
  785		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  786			break
  787		}
  788
  789		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  790
  791	case "ChangeLabelPayload.operation":
  792		if e.complexity.ChangeLabelPayload.Operation == nil {
  793			break
  794		}
  795
  796		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  797
  798	case "ChangeLabelPayload.results":
  799		if e.complexity.ChangeLabelPayload.Results == nil {
  800			break
  801		}
  802
  803		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  804
  805	case "CloseBugPayload.bug":
  806		if e.complexity.CloseBugPayload.Bug == nil {
  807			break
  808		}
  809
  810		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  811
  812	case "CloseBugPayload.clientMutationId":
  813		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  814			break
  815		}
  816
  817		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  818
  819	case "CloseBugPayload.operation":
  820		if e.complexity.CloseBugPayload.Operation == nil {
  821			break
  822		}
  823
  824		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  825
  826	case "Color.B":
  827		if e.complexity.Color.B == nil {
  828			break
  829		}
  830
  831		return e.complexity.Color.B(childComplexity), true
  832
  833	case "Color.G":
  834		if e.complexity.Color.G == nil {
  835			break
  836		}
  837
  838		return e.complexity.Color.G(childComplexity), true
  839
  840	case "Color.R":
  841		if e.complexity.Color.R == nil {
  842			break
  843		}
  844
  845		return e.complexity.Color.R(childComplexity), true
  846
  847	case "Comment.author":
  848		if e.complexity.Comment.Author == nil {
  849			break
  850		}
  851
  852		return e.complexity.Comment.Author(childComplexity), true
  853
  854	case "Comment.files":
  855		if e.complexity.Comment.Files == nil {
  856			break
  857		}
  858
  859		return e.complexity.Comment.Files(childComplexity), true
  860
  861	case "Comment.message":
  862		if e.complexity.Comment.Message == nil {
  863			break
  864		}
  865
  866		return e.complexity.Comment.Message(childComplexity), true
  867
  868	case "CommentConnection.edges":
  869		if e.complexity.CommentConnection.Edges == nil {
  870			break
  871		}
  872
  873		return e.complexity.CommentConnection.Edges(childComplexity), true
  874
  875	case "CommentConnection.nodes":
  876		if e.complexity.CommentConnection.Nodes == nil {
  877			break
  878		}
  879
  880		return e.complexity.CommentConnection.Nodes(childComplexity), true
  881
  882	case "CommentConnection.pageInfo":
  883		if e.complexity.CommentConnection.PageInfo == nil {
  884			break
  885		}
  886
  887		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  888
  889	case "CommentConnection.totalCount":
  890		if e.complexity.CommentConnection.TotalCount == nil {
  891			break
  892		}
  893
  894		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  895
  896	case "CommentEdge.cursor":
  897		if e.complexity.CommentEdge.Cursor == nil {
  898			break
  899		}
  900
  901		return e.complexity.CommentEdge.Cursor(childComplexity), true
  902
  903	case "CommentEdge.node":
  904		if e.complexity.CommentEdge.Node == nil {
  905			break
  906		}
  907
  908		return e.complexity.CommentEdge.Node(childComplexity), true
  909
  910	case "CommentHistoryStep.date":
  911		if e.complexity.CommentHistoryStep.Date == nil {
  912			break
  913		}
  914
  915		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  916
  917	case "CommentHistoryStep.message":
  918		if e.complexity.CommentHistoryStep.Message == nil {
  919			break
  920		}
  921
  922		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  923
  924	case "CommitAsNeededPayload.bug":
  925		if e.complexity.CommitAsNeededPayload.Bug == nil {
  926			break
  927		}
  928
  929		return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
  930
  931	case "CommitAsNeededPayload.clientMutationId":
  932		if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
  933			break
  934		}
  935
  936		return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
  937
  938	case "CommitPayload.bug":
  939		if e.complexity.CommitPayload.Bug == nil {
  940			break
  941		}
  942
  943		return e.complexity.CommitPayload.Bug(childComplexity), true
  944
  945	case "CommitPayload.clientMutationId":
  946		if e.complexity.CommitPayload.ClientMutationID == nil {
  947			break
  948		}
  949
  950		return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
  951
  952	case "CreateOperation.author":
  953		if e.complexity.CreateOperation.Author == nil {
  954			break
  955		}
  956
  957		return e.complexity.CreateOperation.Author(childComplexity), true
  958
  959	case "CreateOperation.date":
  960		if e.complexity.CreateOperation.Date == nil {
  961			break
  962		}
  963
  964		return e.complexity.CreateOperation.Date(childComplexity), true
  965
  966	case "CreateOperation.files":
  967		if e.complexity.CreateOperation.Files == nil {
  968			break
  969		}
  970
  971		return e.complexity.CreateOperation.Files(childComplexity), true
  972
  973	case "CreateOperation.id":
  974		if e.complexity.CreateOperation.ID == nil {
  975			break
  976		}
  977
  978		return e.complexity.CreateOperation.ID(childComplexity), true
  979
  980	case "CreateOperation.message":
  981		if e.complexity.CreateOperation.Message == nil {
  982			break
  983		}
  984
  985		return e.complexity.CreateOperation.Message(childComplexity), true
  986
  987	case "CreateOperation.title":
  988		if e.complexity.CreateOperation.Title == nil {
  989			break
  990		}
  991
  992		return e.complexity.CreateOperation.Title(childComplexity), true
  993
  994	case "CreateTimelineItem.author":
  995		if e.complexity.CreateTimelineItem.Author == nil {
  996			break
  997		}
  998
  999		return e.complexity.CreateTimelineItem.Author(childComplexity), true
 1000
 1001	case "CreateTimelineItem.createdAt":
 1002		if e.complexity.CreateTimelineItem.CreatedAt == nil {
 1003			break
 1004		}
 1005
 1006		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
 1007
 1008	case "CreateTimelineItem.edited":
 1009		if e.complexity.CreateTimelineItem.Edited == nil {
 1010			break
 1011		}
 1012
 1013		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
 1014
 1015	case "CreateTimelineItem.files":
 1016		if e.complexity.CreateTimelineItem.Files == nil {
 1017			break
 1018		}
 1019
 1020		return e.complexity.CreateTimelineItem.Files(childComplexity), true
 1021
 1022	case "CreateTimelineItem.history":
 1023		if e.complexity.CreateTimelineItem.History == nil {
 1024			break
 1025		}
 1026
 1027		return e.complexity.CreateTimelineItem.History(childComplexity), true
 1028
 1029	case "CreateTimelineItem.id":
 1030		if e.complexity.CreateTimelineItem.ID == nil {
 1031			break
 1032		}
 1033
 1034		return e.complexity.CreateTimelineItem.ID(childComplexity), true
 1035
 1036	case "CreateTimelineItem.lastEdit":
 1037		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1038			break
 1039		}
 1040
 1041		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1042
 1043	case "CreateTimelineItem.message":
 1044		if e.complexity.CreateTimelineItem.Message == nil {
 1045			break
 1046		}
 1047
 1048		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1049
 1050	case "CreateTimelineItem.messageIsEmpty":
 1051		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1052			break
 1053		}
 1054
 1055		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1056
 1057	case "EditCommentOperation.author":
 1058		if e.complexity.EditCommentOperation.Author == nil {
 1059			break
 1060		}
 1061
 1062		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1063
 1064	case "EditCommentOperation.date":
 1065		if e.complexity.EditCommentOperation.Date == nil {
 1066			break
 1067		}
 1068
 1069		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1070
 1071	case "EditCommentOperation.files":
 1072		if e.complexity.EditCommentOperation.Files == nil {
 1073			break
 1074		}
 1075
 1076		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1077
 1078	case "EditCommentOperation.id":
 1079		if e.complexity.EditCommentOperation.ID == nil {
 1080			break
 1081		}
 1082
 1083		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1084
 1085	case "EditCommentOperation.message":
 1086		if e.complexity.EditCommentOperation.Message == nil {
 1087			break
 1088		}
 1089
 1090		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1091
 1092	case "EditCommentOperation.target":
 1093		if e.complexity.EditCommentOperation.Target == nil {
 1094			break
 1095		}
 1096
 1097		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1098
 1099	case "Identity.avatarUrl":
 1100		if e.complexity.Identity.AvatarUrl == nil {
 1101			break
 1102		}
 1103
 1104		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1105
 1106	case "Identity.displayName":
 1107		if e.complexity.Identity.DisplayName == nil {
 1108			break
 1109		}
 1110
 1111		return e.complexity.Identity.DisplayName(childComplexity), true
 1112
 1113	case "Identity.email":
 1114		if e.complexity.Identity.Email == nil {
 1115			break
 1116		}
 1117
 1118		return e.complexity.Identity.Email(childComplexity), true
 1119
 1120	case "Identity.humanId":
 1121		if e.complexity.Identity.HumanID == nil {
 1122			break
 1123		}
 1124
 1125		return e.complexity.Identity.HumanID(childComplexity), true
 1126
 1127	case "Identity.id":
 1128		if e.complexity.Identity.ID == nil {
 1129			break
 1130		}
 1131
 1132		return e.complexity.Identity.ID(childComplexity), true
 1133
 1134	case "Identity.isProtected":
 1135		if e.complexity.Identity.IsProtected == nil {
 1136			break
 1137		}
 1138
 1139		return e.complexity.Identity.IsProtected(childComplexity), true
 1140
 1141	case "Identity.name":
 1142		if e.complexity.Identity.Name == nil {
 1143			break
 1144		}
 1145
 1146		return e.complexity.Identity.Name(childComplexity), true
 1147
 1148	case "IdentityConnection.edges":
 1149		if e.complexity.IdentityConnection.Edges == nil {
 1150			break
 1151		}
 1152
 1153		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1154
 1155	case "IdentityConnection.nodes":
 1156		if e.complexity.IdentityConnection.Nodes == nil {
 1157			break
 1158		}
 1159
 1160		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1161
 1162	case "IdentityConnection.pageInfo":
 1163		if e.complexity.IdentityConnection.PageInfo == nil {
 1164			break
 1165		}
 1166
 1167		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1168
 1169	case "IdentityConnection.totalCount":
 1170		if e.complexity.IdentityConnection.TotalCount == nil {
 1171			break
 1172		}
 1173
 1174		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1175
 1176	case "IdentityEdge.cursor":
 1177		if e.complexity.IdentityEdge.Cursor == nil {
 1178			break
 1179		}
 1180
 1181		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1182
 1183	case "IdentityEdge.node":
 1184		if e.complexity.IdentityEdge.Node == nil {
 1185			break
 1186		}
 1187
 1188		return e.complexity.IdentityEdge.Node(childComplexity), true
 1189
 1190	case "Label.color":
 1191		if e.complexity.Label.Color == nil {
 1192			break
 1193		}
 1194
 1195		return e.complexity.Label.Color(childComplexity), true
 1196
 1197	case "Label.name":
 1198		if e.complexity.Label.Name == nil {
 1199			break
 1200		}
 1201
 1202		return e.complexity.Label.Name(childComplexity), true
 1203
 1204	case "LabelChangeOperation.added":
 1205		if e.complexity.LabelChangeOperation.Added == nil {
 1206			break
 1207		}
 1208
 1209		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1210
 1211	case "LabelChangeOperation.author":
 1212		if e.complexity.LabelChangeOperation.Author == nil {
 1213			break
 1214		}
 1215
 1216		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1217
 1218	case "LabelChangeOperation.date":
 1219		if e.complexity.LabelChangeOperation.Date == nil {
 1220			break
 1221		}
 1222
 1223		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1224
 1225	case "LabelChangeOperation.id":
 1226		if e.complexity.LabelChangeOperation.ID == nil {
 1227			break
 1228		}
 1229
 1230		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1231
 1232	case "LabelChangeOperation.removed":
 1233		if e.complexity.LabelChangeOperation.Removed == nil {
 1234			break
 1235		}
 1236
 1237		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1238
 1239	case "LabelChangeResult.label":
 1240		if e.complexity.LabelChangeResult.Label == nil {
 1241			break
 1242		}
 1243
 1244		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1245
 1246	case "LabelChangeResult.status":
 1247		if e.complexity.LabelChangeResult.Status == nil {
 1248			break
 1249		}
 1250
 1251		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1252
 1253	case "LabelChangeTimelineItem.added":
 1254		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1255			break
 1256		}
 1257
 1258		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1259
 1260	case "LabelChangeTimelineItem.author":
 1261		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1262			break
 1263		}
 1264
 1265		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1266
 1267	case "LabelChangeTimelineItem.date":
 1268		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1269			break
 1270		}
 1271
 1272		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1273
 1274	case "LabelChangeTimelineItem.id":
 1275		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1276			break
 1277		}
 1278
 1279		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1280
 1281	case "LabelChangeTimelineItem.removed":
 1282		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1283			break
 1284		}
 1285
 1286		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1287
 1288	case "LabelConnection.edges":
 1289		if e.complexity.LabelConnection.Edges == nil {
 1290			break
 1291		}
 1292
 1293		return e.complexity.LabelConnection.Edges(childComplexity), true
 1294
 1295	case "LabelConnection.nodes":
 1296		if e.complexity.LabelConnection.Nodes == nil {
 1297			break
 1298		}
 1299
 1300		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1301
 1302	case "LabelConnection.pageInfo":
 1303		if e.complexity.LabelConnection.PageInfo == nil {
 1304			break
 1305		}
 1306
 1307		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1308
 1309	case "LabelConnection.totalCount":
 1310		if e.complexity.LabelConnection.TotalCount == nil {
 1311			break
 1312		}
 1313
 1314		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1315
 1316	case "LabelEdge.cursor":
 1317		if e.complexity.LabelEdge.Cursor == nil {
 1318			break
 1319		}
 1320
 1321		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1322
 1323	case "LabelEdge.node":
 1324		if e.complexity.LabelEdge.Node == nil {
 1325			break
 1326		}
 1327
 1328		return e.complexity.LabelEdge.Node(childComplexity), true
 1329
 1330	case "Mutation.addComment":
 1331		if e.complexity.Mutation.AddComment == nil {
 1332			break
 1333		}
 1334
 1335		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1336		if err != nil {
 1337			return 0, false
 1338		}
 1339
 1340		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1341
 1342	case "Mutation.changeLabels":
 1343		if e.complexity.Mutation.ChangeLabels == nil {
 1344			break
 1345		}
 1346
 1347		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1348		if err != nil {
 1349			return 0, false
 1350		}
 1351
 1352		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1353
 1354	case "Mutation.closeBug":
 1355		if e.complexity.Mutation.CloseBug == nil {
 1356			break
 1357		}
 1358
 1359		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1360		if err != nil {
 1361			return 0, false
 1362		}
 1363
 1364		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1365
 1366	case "Mutation.commit":
 1367		if e.complexity.Mutation.Commit == nil {
 1368			break
 1369		}
 1370
 1371		args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
 1372		if err != nil {
 1373			return 0, false
 1374		}
 1375
 1376		return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
 1377
 1378	case "Mutation.commitAsNeeded":
 1379		if e.complexity.Mutation.CommitAsNeeded == nil {
 1380			break
 1381		}
 1382
 1383		args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
 1384		if err != nil {
 1385			return 0, false
 1386		}
 1387
 1388		return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
 1389
 1390	case "Mutation.newBug":
 1391		if e.complexity.Mutation.NewBug == nil {
 1392			break
 1393		}
 1394
 1395		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1396		if err != nil {
 1397			return 0, false
 1398		}
 1399
 1400		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1401
 1402	case "Mutation.openBug":
 1403		if e.complexity.Mutation.OpenBug == nil {
 1404			break
 1405		}
 1406
 1407		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1408		if err != nil {
 1409			return 0, false
 1410		}
 1411
 1412		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1413
 1414	case "Mutation.setTitle":
 1415		if e.complexity.Mutation.SetTitle == nil {
 1416			break
 1417		}
 1418
 1419		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1420		if err != nil {
 1421			return 0, false
 1422		}
 1423
 1424		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1425
 1426	case "NewBugPayload.bug":
 1427		if e.complexity.NewBugPayload.Bug == nil {
 1428			break
 1429		}
 1430
 1431		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1432
 1433	case "NewBugPayload.clientMutationId":
 1434		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1435			break
 1436		}
 1437
 1438		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1439
 1440	case "NewBugPayload.operation":
 1441		if e.complexity.NewBugPayload.Operation == nil {
 1442			break
 1443		}
 1444
 1445		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1446
 1447	case "OpenBugPayload.bug":
 1448		if e.complexity.OpenBugPayload.Bug == nil {
 1449			break
 1450		}
 1451
 1452		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1453
 1454	case "OpenBugPayload.clientMutationId":
 1455		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1456			break
 1457		}
 1458
 1459		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1460
 1461	case "OpenBugPayload.operation":
 1462		if e.complexity.OpenBugPayload.Operation == nil {
 1463			break
 1464		}
 1465
 1466		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1467
 1468	case "OperationConnection.edges":
 1469		if e.complexity.OperationConnection.Edges == nil {
 1470			break
 1471		}
 1472
 1473		return e.complexity.OperationConnection.Edges(childComplexity), true
 1474
 1475	case "OperationConnection.nodes":
 1476		if e.complexity.OperationConnection.Nodes == nil {
 1477			break
 1478		}
 1479
 1480		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1481
 1482	case "OperationConnection.pageInfo":
 1483		if e.complexity.OperationConnection.PageInfo == nil {
 1484			break
 1485		}
 1486
 1487		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1488
 1489	case "OperationConnection.totalCount":
 1490		if e.complexity.OperationConnection.TotalCount == nil {
 1491			break
 1492		}
 1493
 1494		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1495
 1496	case "OperationEdge.cursor":
 1497		if e.complexity.OperationEdge.Cursor == nil {
 1498			break
 1499		}
 1500
 1501		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1502
 1503	case "OperationEdge.node":
 1504		if e.complexity.OperationEdge.Node == nil {
 1505			break
 1506		}
 1507
 1508		return e.complexity.OperationEdge.Node(childComplexity), true
 1509
 1510	case "PageInfo.endCursor":
 1511		if e.complexity.PageInfo.EndCursor == nil {
 1512			break
 1513		}
 1514
 1515		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1516
 1517	case "PageInfo.hasNextPage":
 1518		if e.complexity.PageInfo.HasNextPage == nil {
 1519			break
 1520		}
 1521
 1522		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1523
 1524	case "PageInfo.hasPreviousPage":
 1525		if e.complexity.PageInfo.HasPreviousPage == nil {
 1526			break
 1527		}
 1528
 1529		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1530
 1531	case "PageInfo.startCursor":
 1532		if e.complexity.PageInfo.StartCursor == nil {
 1533			break
 1534		}
 1535
 1536		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1537
 1538	case "Query.defaultRepository":
 1539		if e.complexity.Query.DefaultRepository == nil {
 1540			break
 1541		}
 1542
 1543		return e.complexity.Query.DefaultRepository(childComplexity), true
 1544
 1545	case "Query.repository":
 1546		if e.complexity.Query.Repository == nil {
 1547			break
 1548		}
 1549
 1550		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1551		if err != nil {
 1552			return 0, false
 1553		}
 1554
 1555		return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
 1556
 1557	case "Repository.allBugs":
 1558		if e.complexity.Repository.AllBugs == nil {
 1559			break
 1560		}
 1561
 1562		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1563		if err != nil {
 1564			return 0, false
 1565		}
 1566
 1567		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1568
 1569	case "Repository.allIdentities":
 1570		if e.complexity.Repository.AllIdentities == nil {
 1571			break
 1572		}
 1573
 1574		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1575		if err != nil {
 1576			return 0, false
 1577		}
 1578
 1579		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1580
 1581	case "Repository.bug":
 1582		if e.complexity.Repository.Bug == nil {
 1583			break
 1584		}
 1585
 1586		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1587		if err != nil {
 1588			return 0, false
 1589		}
 1590
 1591		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1592
 1593	case "Repository.identity":
 1594		if e.complexity.Repository.Identity == nil {
 1595			break
 1596		}
 1597
 1598		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1599		if err != nil {
 1600			return 0, false
 1601		}
 1602
 1603		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1604
 1605	case "Repository.userIdentity":
 1606		if e.complexity.Repository.UserIdentity == nil {
 1607			break
 1608		}
 1609
 1610		return e.complexity.Repository.UserIdentity(childComplexity), true
 1611
 1612	case "Repository.validLabels":
 1613		if e.complexity.Repository.ValidLabels == nil {
 1614			break
 1615		}
 1616
 1617		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1618		if err != nil {
 1619			return 0, false
 1620		}
 1621
 1622		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1623
 1624	case "SetStatusOperation.author":
 1625		if e.complexity.SetStatusOperation.Author == nil {
 1626			break
 1627		}
 1628
 1629		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1630
 1631	case "SetStatusOperation.date":
 1632		if e.complexity.SetStatusOperation.Date == nil {
 1633			break
 1634		}
 1635
 1636		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1637
 1638	case "SetStatusOperation.id":
 1639		if e.complexity.SetStatusOperation.ID == nil {
 1640			break
 1641		}
 1642
 1643		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1644
 1645	case "SetStatusOperation.status":
 1646		if e.complexity.SetStatusOperation.Status == nil {
 1647			break
 1648		}
 1649
 1650		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1651
 1652	case "SetStatusTimelineItem.author":
 1653		if e.complexity.SetStatusTimelineItem.Author == nil {
 1654			break
 1655		}
 1656
 1657		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1658
 1659	case "SetStatusTimelineItem.date":
 1660		if e.complexity.SetStatusTimelineItem.Date == nil {
 1661			break
 1662		}
 1663
 1664		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1665
 1666	case "SetStatusTimelineItem.id":
 1667		if e.complexity.SetStatusTimelineItem.ID == nil {
 1668			break
 1669		}
 1670
 1671		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1672
 1673	case "SetStatusTimelineItem.status":
 1674		if e.complexity.SetStatusTimelineItem.Status == nil {
 1675			break
 1676		}
 1677
 1678		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1679
 1680	case "SetTitleOperation.author":
 1681		if e.complexity.SetTitleOperation.Author == nil {
 1682			break
 1683		}
 1684
 1685		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1686
 1687	case "SetTitleOperation.date":
 1688		if e.complexity.SetTitleOperation.Date == nil {
 1689			break
 1690		}
 1691
 1692		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1693
 1694	case "SetTitleOperation.id":
 1695		if e.complexity.SetTitleOperation.ID == nil {
 1696			break
 1697		}
 1698
 1699		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1700
 1701	case "SetTitleOperation.title":
 1702		if e.complexity.SetTitleOperation.Title == nil {
 1703			break
 1704		}
 1705
 1706		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1707
 1708	case "SetTitleOperation.was":
 1709		if e.complexity.SetTitleOperation.Was == nil {
 1710			break
 1711		}
 1712
 1713		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1714
 1715	case "SetTitlePayload.bug":
 1716		if e.complexity.SetTitlePayload.Bug == nil {
 1717			break
 1718		}
 1719
 1720		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1721
 1722	case "SetTitlePayload.clientMutationId":
 1723		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1724			break
 1725		}
 1726
 1727		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1728
 1729	case "SetTitlePayload.operation":
 1730		if e.complexity.SetTitlePayload.Operation == nil {
 1731			break
 1732		}
 1733
 1734		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1735
 1736	case "SetTitleTimelineItem.author":
 1737		if e.complexity.SetTitleTimelineItem.Author == nil {
 1738			break
 1739		}
 1740
 1741		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1742
 1743	case "SetTitleTimelineItem.date":
 1744		if e.complexity.SetTitleTimelineItem.Date == nil {
 1745			break
 1746		}
 1747
 1748		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1749
 1750	case "SetTitleTimelineItem.id":
 1751		if e.complexity.SetTitleTimelineItem.ID == nil {
 1752			break
 1753		}
 1754
 1755		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1756
 1757	case "SetTitleTimelineItem.title":
 1758		if e.complexity.SetTitleTimelineItem.Title == nil {
 1759			break
 1760		}
 1761
 1762		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1763
 1764	case "SetTitleTimelineItem.was":
 1765		if e.complexity.SetTitleTimelineItem.Was == nil {
 1766			break
 1767		}
 1768
 1769		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1770
 1771	case "TimelineItemConnection.edges":
 1772		if e.complexity.TimelineItemConnection.Edges == nil {
 1773			break
 1774		}
 1775
 1776		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1777
 1778	case "TimelineItemConnection.nodes":
 1779		if e.complexity.TimelineItemConnection.Nodes == nil {
 1780			break
 1781		}
 1782
 1783		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1784
 1785	case "TimelineItemConnection.pageInfo":
 1786		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1787			break
 1788		}
 1789
 1790		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1791
 1792	case "TimelineItemConnection.totalCount":
 1793		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1794			break
 1795		}
 1796
 1797		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1798
 1799	case "TimelineItemEdge.cursor":
 1800		if e.complexity.TimelineItemEdge.Cursor == nil {
 1801			break
 1802		}
 1803
 1804		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1805
 1806	case "TimelineItemEdge.node":
 1807		if e.complexity.TimelineItemEdge.Node == nil {
 1808			break
 1809		}
 1810
 1811		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1812
 1813	}
 1814	return 0, false
 1815}
 1816
 1817func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1818	rc := graphql.GetOperationContext(ctx)
 1819	ec := executionContext{rc, e}
 1820	first := true
 1821
 1822	switch rc.Operation.Operation {
 1823	case ast.Query:
 1824		return func(ctx context.Context) *graphql.Response {
 1825			if !first {
 1826				return nil
 1827			}
 1828			first = false
 1829			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1830			var buf bytes.Buffer
 1831			data.MarshalGQL(&buf)
 1832
 1833			return &graphql.Response{
 1834				Data: buf.Bytes(),
 1835			}
 1836		}
 1837	case ast.Mutation:
 1838		return func(ctx context.Context) *graphql.Response {
 1839			if !first {
 1840				return nil
 1841			}
 1842			first = false
 1843			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1844			var buf bytes.Buffer
 1845			data.MarshalGQL(&buf)
 1846
 1847			return &graphql.Response{
 1848				Data: buf.Bytes(),
 1849			}
 1850		}
 1851
 1852	default:
 1853		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1854	}
 1855}
 1856
 1857type executionContext struct {
 1858	*graphql.OperationContext
 1859	*executableSchema
 1860}
 1861
 1862func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1863	if ec.DisableIntrospection {
 1864		return nil, errors.New("introspection disabled")
 1865	}
 1866	return introspection.WrapSchema(parsedSchema), nil
 1867}
 1868
 1869func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1870	if ec.DisableIntrospection {
 1871		return nil, errors.New("introspection disabled")
 1872	}
 1873	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1874}
 1875
 1876var parsedSchema = gqlparser.MustLoadSchema(
 1877	&ast.Source{Name: "schema.graphql", Input: `input AddCommentInput {
 1878	"""
 1879	A unique identifier for the client performing the mutation.
 1880	"""
 1881	clientMutationId: String
 1882	"""
 1883	"The name of the repository. If not set, the default repository is used.
 1884	"""
 1885	repoRef: String
 1886	"""
 1887	The bug ID's prefix.
 1888	"""
 1889	prefix: String!
 1890	"""
 1891	The first message of the new bug.
 1892	"""
 1893	message: String!
 1894	"""
 1895	The collection of file's hash required for the first message.
 1896	"""
 1897	files: [Hash!]
 1898}
 1899type AddCommentOperation implements Operation & Authored {
 1900	"""
 1901	The identifier of the operation
 1902	"""
 1903	id: String!
 1904	"""
 1905	The author of this object.
 1906	"""
 1907	author: Identity!
 1908	"""
 1909	The datetime when this operation was issued.
 1910	"""
 1911	date: Time!
 1912	message: String!
 1913	files: [Hash!]!
 1914}
 1915type AddCommentPayload {
 1916	"""
 1917	A unique identifier for the client performing the mutation.
 1918	"""
 1919	clientMutationId: String
 1920	"""
 1921	The affected bug.
 1922	"""
 1923	bug: Bug!
 1924	"""
 1925	The resulting operation.
 1926	"""
 1927	operation: AddCommentOperation!
 1928}
 1929"""
 1930AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history
 1931"""
 1932type AddCommentTimelineItem implements TimelineItem & Authored {
 1933	"""
 1934	The identifier of the source operation
 1935	"""
 1936	id: String!
 1937	author: Identity!
 1938	message: String!
 1939	messageIsEmpty: Boolean!
 1940	files: [Hash!]!
 1941	createdAt: Time!
 1942	lastEdit: Time!
 1943	edited: Boolean!
 1944	history: [CommentHistoryStep!]!
 1945}
 1946"""
 1947An object that has an author.
 1948"""
 1949interface Authored {
 1950	"""
 1951	The author of this object.
 1952	"""
 1953	author: Identity!
 1954}
 1955type Bug implements Authored {
 1956	"""
 1957	The identifier for this bug
 1958	"""
 1959	id: String!
 1960	"""
 1961	The human version (truncated) identifier for this bug
 1962	"""
 1963	humanId: String!
 1964	status: Status!
 1965	title: String!
 1966	labels: [Label!]!
 1967	author: Identity!
 1968	createdAt: Time!
 1969	lastEdit: Time!
 1970	"""
 1971	The actors of the bug. Actors are Identity that have interacted with the bug.
 1972	"""
 1973	actors("""
 1974	Returns the elements in the list that come after the specified cursor.
 1975	"""
 1976	after: String, """
 1977	Returns the elements in the list that come before the specified cursor.
 1978	"""
 1979	before: String, """
 1980	Returns the first _n_ elements from the list.
 1981	"""
 1982	first: Int, """
 1983	Returns the last _n_ elements from the list.
 1984	"""
 1985	last: Int): IdentityConnection!
 1986	"""
 1987	The participants of the bug. Participants are Identity that have created or
 1988	  added a comment on the bug.
 1989	"""
 1990	participants("""
 1991	Returns the elements in the list that come after the specified cursor.
 1992	"""
 1993	after: String, """
 1994	Returns the elements in the list that come before the specified cursor.
 1995	"""
 1996	before: String, """
 1997	Returns the first _n_ elements from the list.
 1998	"""
 1999	first: Int, """
 2000	Returns the last _n_ elements from the list.
 2001	"""
 2002	last: Int): IdentityConnection!
 2003	comments("""
 2004	Returns the elements in the list that come after the specified cursor.
 2005	"""
 2006	after: String, """
 2007	Returns the elements in the list that come before the specified cursor.
 2008	"""
 2009	before: String, """
 2010	Returns the first _n_ elements from the list.
 2011	"""
 2012	first: Int, """
 2013	Returns the last _n_ elements from the list.
 2014	"""
 2015	last: Int): CommentConnection!
 2016	timeline("""
 2017	Returns the elements in the list that come after the specified cursor.
 2018	"""
 2019	after: String, """
 2020	Returns the elements in the list that come before the specified cursor.
 2021	"""
 2022	before: String, """
 2023	Returns the first _n_ elements from the list.
 2024	"""
 2025	first: Int, """
 2026	Returns the last _n_ elements from the list.
 2027	"""
 2028	last: Int): TimelineItemConnection!
 2029	operations("""
 2030	Returns the elements in the list that come after the specified cursor.
 2031	"""
 2032	after: String, """
 2033	Returns the elements in the list that come before the specified cursor.
 2034	"""
 2035	before: String, """
 2036	Returns the first _n_ elements from the list.
 2037	"""
 2038	first: Int, """
 2039	Returns the last _n_ elements from the list.
 2040	"""
 2041	last: Int): OperationConnection!
 2042}
 2043"""
 2044The connection type for Bug.
 2045"""
 2046type BugConnection {
 2047	"""
 2048	A list of edges.
 2049	"""
 2050	edges: [BugEdge!]!
 2051	nodes: [Bug!]!
 2052	"""
 2053	Information to aid in pagination.
 2054	"""
 2055	pageInfo: PageInfo!
 2056	"""
 2057	Identifies the total count of items in the connection.
 2058	"""
 2059	totalCount: Int!
 2060}
 2061"""
 2062An edge in a connection.
 2063"""
 2064type BugEdge {
 2065	"""
 2066	A cursor for use in pagination.
 2067	"""
 2068	cursor: String!
 2069	"""
 2070	The item at the end of the edge.
 2071	"""
 2072	node: Bug!
 2073}
 2074input ChangeLabelInput {
 2075	"""
 2076	A unique identifier for the client performing the mutation.
 2077	"""
 2078	clientMutationId: String
 2079	"""
 2080	"The name of the repository. If not set, the default repository is used.
 2081	"""
 2082	repoRef: String
 2083	"""
 2084	The bug ID's prefix.
 2085	"""
 2086	prefix: String!
 2087	"""
 2088	The list of label to add.
 2089	"""
 2090	added: [String!]
 2091	"""
 2092	The list of label to remove.
 2093	"""
 2094	Removed: [String!]
 2095}
 2096type ChangeLabelPayload {
 2097	"""
 2098	A unique identifier for the client performing the mutation.
 2099	"""
 2100	clientMutationId: String
 2101	"""
 2102	The affected bug.
 2103	"""
 2104	bug: Bug!
 2105	"""
 2106	The resulting operation.
 2107	"""
 2108	operation: LabelChangeOperation!
 2109	"""
 2110	The effect each source label had.
 2111	"""
 2112	results: [LabelChangeResult]!
 2113}
 2114input CloseBugInput {
 2115	"""
 2116	A unique identifier for the client performing the mutation.
 2117	"""
 2118	clientMutationId: String
 2119	"""
 2120	"The name of the repository. If not set, the default repository is used.
 2121	"""
 2122	repoRef: String
 2123	"""
 2124	The bug ID's prefix.
 2125	"""
 2126	prefix: String!
 2127}
 2128type CloseBugPayload {
 2129	"""
 2130	A unique identifier for the client performing the mutation.
 2131	"""
 2132	clientMutationId: String
 2133	"""
 2134	The affected bug.
 2135	"""
 2136	bug: Bug!
 2137	"""
 2138	The resulting operation.
 2139	"""
 2140	operation: SetStatusOperation!
 2141}
 2142"""
 2143Defines a color by red, green and blue components.
 2144"""
 2145type Color {
 2146	"""
 2147	Red component of the color.
 2148	"""
 2149	R: Int!
 2150	"""
 2151	Green component of the color.
 2152	"""
 2153	G: Int!
 2154	"""
 2155	Blue component of the color.
 2156	"""
 2157	B: Int!
 2158}
 2159"""
 2160Represents a comment on a bug.
 2161"""
 2162type Comment implements Authored {
 2163	"""
 2164	The author of this comment.
 2165	"""
 2166	author: Identity!
 2167	"""
 2168	The message of this comment.
 2169	"""
 2170	message: String!
 2171	"""
 2172	All media's hash referenced in this comment
 2173	"""
 2174	files: [Hash!]!
 2175}
 2176type CommentConnection {
 2177	edges: [CommentEdge!]!
 2178	nodes: [Comment!]!
 2179	pageInfo: PageInfo!
 2180	totalCount: Int!
 2181}
 2182type CommentEdge {
 2183	cursor: String!
 2184	node: Comment!
 2185}
 2186"""
 2187CommentHistoryStep hold one version of a message in the history
 2188"""
 2189type CommentHistoryStep {
 2190	message: String!
 2191	date: Time!
 2192}
 2193input CommitAsNeededInput {
 2194	"""
 2195	A unique identifier for the client performing the mutation.
 2196	"""
 2197	clientMutationId: String
 2198	"""
 2199	"The name of the repository. If not set, the default repository is used.
 2200	"""
 2201	repoRef: String
 2202	"""
 2203	The bug ID's prefix.
 2204	"""
 2205	prefix: String!
 2206}
 2207type CommitAsNeededPayload {
 2208	"""
 2209	A unique identifier for the client performing the mutation.
 2210	"""
 2211	clientMutationId: String
 2212	"""
 2213	The affected bug.
 2214	"""
 2215	bug: Bug!
 2216}
 2217input CommitInput {
 2218	"""
 2219	A unique identifier for the client performing the mutation.
 2220	"""
 2221	clientMutationId: String
 2222	"""
 2223	"The name of the repository. If not set, the default repository is used.
 2224	"""
 2225	repoRef: String
 2226	"""
 2227	The bug ID's prefix.
 2228	"""
 2229	prefix: String!
 2230}
 2231type CommitPayload {
 2232	"""
 2233	A unique identifier for the client performing the mutation.
 2234	"""
 2235	clientMutationId: String
 2236	"""
 2237	The affected bug.
 2238	"""
 2239	bug: Bug!
 2240}
 2241type CreateOperation implements Operation & Authored {
 2242	"""
 2243	The identifier of the operation
 2244	"""
 2245	id: String!
 2246	"""
 2247	The author of this object.
 2248	"""
 2249	author: Identity!
 2250	"""
 2251	The datetime when this operation was issued.
 2252	"""
 2253	date: Time!
 2254	title: String!
 2255	message: String!
 2256	files: [Hash!]!
 2257}
 2258"""
 2259CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history
 2260"""
 2261type CreateTimelineItem implements TimelineItem & Authored {
 2262	"""
 2263	The identifier of the source operation
 2264	"""
 2265	id: String!
 2266	author: Identity!
 2267	message: String!
 2268	messageIsEmpty: Boolean!
 2269	files: [Hash!]!
 2270	createdAt: Time!
 2271	lastEdit: Time!
 2272	edited: Boolean!
 2273	history: [CommentHistoryStep!]!
 2274}
 2275type EditCommentOperation implements Operation & Authored {
 2276	"""
 2277	The identifier of the operation
 2278	"""
 2279	id: String!
 2280	"""
 2281	The author of this object.
 2282	"""
 2283	author: Identity!
 2284	"""
 2285	The datetime when this operation was issued.
 2286	"""
 2287	date: Time!
 2288	target: String!
 2289	message: String!
 2290	files: [Hash!]!
 2291}
 2292scalar Hash
 2293"""
 2294Represents an identity
 2295"""
 2296type Identity {
 2297	"""
 2298	The identifier for this identity
 2299	"""
 2300	id: String!
 2301	"""
 2302	The human version (truncated) identifier for this identity
 2303	"""
 2304	humanId: String!
 2305	"""
 2306	The name of the person, if known.
 2307	"""
 2308	name: String
 2309	"""
 2310	The email of the person, if known.
 2311	"""
 2312	email: String
 2313	"""
 2314	A non-empty string to display, representing the identity, based on the non-empty values.
 2315	"""
 2316	displayName: String!
 2317	"""
 2318	An url to an avatar
 2319	"""
 2320	avatarUrl: String
 2321	"""
 2322	isProtected is true if the chain of git commits started to be signed.
 2323	    If that's the case, only signed commit with a valid key for this identity can be added.
 2324	"""
 2325	isProtected: Boolean!
 2326}
 2327type IdentityConnection {
 2328	edges: [IdentityEdge!]!
 2329	nodes: [Identity!]!
 2330	pageInfo: PageInfo!
 2331	totalCount: Int!
 2332}
 2333type IdentityEdge {
 2334	cursor: String!
 2335	node: Identity!
 2336}
 2337"""
 2338Label for a bug.
 2339"""
 2340type Label {
 2341	"""
 2342	The name of the label.
 2343	"""
 2344	name: String!
 2345	"""
 2346	Color of the label.
 2347	"""
 2348	color: Color!
 2349}
 2350type LabelChangeOperation implements Operation & Authored {
 2351	"""
 2352	The identifier of the operation
 2353	"""
 2354	id: String!
 2355	"""
 2356	The author of this object.
 2357	"""
 2358	author: Identity!
 2359	"""
 2360	The datetime when this operation was issued.
 2361	"""
 2362	date: Time!
 2363	added: [Label!]!
 2364	removed: [Label!]!
 2365}
 2366type LabelChangeResult {
 2367	"""
 2368	The source label.
 2369	"""
 2370	label: Label!
 2371	"""
 2372	The effect this label had.
 2373	"""
 2374	status: LabelChangeStatus!
 2375}
 2376enum LabelChangeStatus {
 2377	ADDED
 2378	REMOVED
 2379	DUPLICATE_IN_OP
 2380	ALREADY_EXIST
 2381	DOESNT_EXIST
 2382}
 2383"""
 2384LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug
 2385"""
 2386type LabelChangeTimelineItem implements TimelineItem & Authored {
 2387	"""
 2388	The identifier of the source operation
 2389	"""
 2390	id: String!
 2391	author: Identity!
 2392	date: Time!
 2393	added: [Label!]!
 2394	removed: [Label!]!
 2395}
 2396type LabelConnection {
 2397	edges: [LabelEdge!]!
 2398	nodes: [Label!]!
 2399	pageInfo: PageInfo!
 2400	totalCount: Int!
 2401}
 2402type LabelEdge {
 2403	cursor: String!
 2404	node: Label!
 2405}
 2406type Mutation {
 2407	"""
 2408	Create a new bug
 2409	"""
 2410	newBug(input: NewBugInput!): NewBugPayload!
 2411	"""
 2412	Add a new comment to a bug
 2413	"""
 2414	addComment(input: AddCommentInput!): AddCommentPayload!
 2415	"""
 2416	Add or remove a set of label on a bug
 2417	"""
 2418	changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2419	"""
 2420	Change a bug's status to open
 2421	"""
 2422	openBug(input: OpenBugInput!): OpenBugPayload!
 2423	"""
 2424	Change a bug's status to closed
 2425	"""
 2426	closeBug(input: CloseBugInput!): CloseBugPayload!
 2427	"""
 2428	Change a bug's title
 2429	"""
 2430	setTitle(input: SetTitleInput!): SetTitlePayload!
 2431	"""
 2432	Commit write the pending operations into storage. This mutation fail if nothing is pending
 2433	"""
 2434	commit(input: CommitInput!): CommitPayload!
 2435	"""
 2436	Commit write the pending operations into storage. This mutation succed if nothing is pending
 2437	"""
 2438	commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
 2439}
 2440input NewBugInput {
 2441	"""
 2442	A unique identifier for the client performing the mutation.
 2443	"""
 2444	clientMutationId: String
 2445	"""
 2446	"The name of the repository. If not set, the default repository is used.
 2447	"""
 2448	repoRef: String
 2449	"""
 2450	The title of the new bug.
 2451	"""
 2452	title: String!
 2453	"""
 2454	The first message of the new bug.
 2455	"""
 2456	message: String!
 2457	"""
 2458	The collection of file's hash required for the first message.
 2459	"""
 2460	files: [Hash!]
 2461}
 2462type NewBugPayload {
 2463	"""
 2464	A unique identifier for the client performing the mutation.
 2465	"""
 2466	clientMutationId: String
 2467	"""
 2468	The created bug.
 2469	"""
 2470	bug: Bug!
 2471	"""
 2472	The resulting operation.
 2473	"""
 2474	operation: CreateOperation!
 2475}
 2476input OpenBugInput {
 2477	"""
 2478	A unique identifier for the client performing the mutation.
 2479	"""
 2480	clientMutationId: String
 2481	"""
 2482	"The name of the repository. If not set, the default repository is used.
 2483	"""
 2484	repoRef: String
 2485	"""
 2486	The bug ID's prefix.
 2487	"""
 2488	prefix: String!
 2489}
 2490type OpenBugPayload {
 2491	"""
 2492	A unique identifier for the client performing the mutation.
 2493	"""
 2494	clientMutationId: String
 2495	"""
 2496	The affected bug.
 2497	"""
 2498	bug: Bug!
 2499	"""
 2500	The resulting operation.
 2501	"""
 2502	operation: SetStatusOperation!
 2503}
 2504"""
 2505An operation applied to a bug.
 2506"""
 2507interface Operation {
 2508	"""
 2509	The identifier of the operation
 2510	"""
 2511	id: String!
 2512	"""
 2513	The operations author.
 2514	"""
 2515	author: Identity!
 2516	"""
 2517	The datetime when this operation was issued.
 2518	"""
 2519	date: Time!
 2520}
 2521"""
 2522The connection type for an Operation
 2523"""
 2524type OperationConnection {
 2525	edges: [OperationEdge!]!
 2526	nodes: [Operation!]!
 2527	pageInfo: PageInfo!
 2528	totalCount: Int!
 2529}
 2530"""
 2531Represent an Operation
 2532"""
 2533type OperationEdge {
 2534	cursor: String!
 2535	node: Operation!
 2536}
 2537"""
 2538Information about pagination in a connection.
 2539"""
 2540type PageInfo {
 2541	"""
 2542	When paginating forwards, are there more items?
 2543	"""
 2544	hasNextPage: Boolean!
 2545	"""
 2546	When paginating backwards, are there more items?
 2547	"""
 2548	hasPreviousPage: Boolean!
 2549	"""
 2550	When paginating backwards, the cursor to continue.
 2551	"""
 2552	startCursor: String!
 2553	"""
 2554	When paginating forwards, the cursor to continue.
 2555	"""
 2556	endCursor: String!
 2557}
 2558type Query {
 2559	"""
 2560	The default unnamend repository.
 2561	"""
 2562	defaultRepository: Repository
 2563	"""
 2564	Access a repository by reference/name.
 2565	"""
 2566	repository(ref: String!): Repository
 2567}
 2568type Repository {
 2569	"""
 2570	All the bugs
 2571	"""
 2572	allBugs("""
 2573	Returns the elements in the list that come after the specified cursor.
 2574	"""
 2575	after: String, """
 2576	Returns the elements in the list that come before the specified cursor.
 2577	"""
 2578	before: String, """
 2579	Returns the first _n_ elements from the list.
 2580	"""
 2581	first: Int, """
 2582	Returns the last _n_ elements from the list.
 2583	"""
 2584	last: Int, """
 2585	A query to select and order bugs
 2586	"""
 2587	query: String): BugConnection!
 2588	bug(prefix: String!): Bug
 2589	"""
 2590	All the identities
 2591	"""
 2592	allIdentities("""
 2593	Returns the elements in the list that come after the specified cursor.
 2594	"""
 2595	after: String, """
 2596	Returns the elements in the list that come before the specified cursor.
 2597	"""
 2598	before: String, """
 2599	Returns the first _n_ elements from the list.
 2600	"""
 2601	first: Int, """
 2602	Returns the last _n_ elements from the list.
 2603	"""
 2604	last: Int): IdentityConnection!
 2605	identity(prefix: String!): Identity
 2606	"""
 2607	The identity created or selected by the user as its own
 2608	"""
 2609	userIdentity: Identity
 2610	"""
 2611	List of valid labels.
 2612	"""
 2613	validLabels("""
 2614	Returns the elements in the list that come after the specified cursor.
 2615	"""
 2616	after: String, """
 2617	Returns the elements in the list that come before the specified cursor.
 2618	"""
 2619	before: String, """
 2620	Returns the first _n_ elements from the list.
 2621	"""
 2622	first: Int, """
 2623	Returns the last _n_ elements from the list.
 2624	"""
 2625	last: Int): LabelConnection!
 2626}
 2627type SetStatusOperation implements Operation & Authored {
 2628	"""
 2629	The identifier of the operation
 2630	"""
 2631	id: String!
 2632	"""
 2633	The author of this object.
 2634	"""
 2635	author: Identity!
 2636	"""
 2637	The datetime when this operation was issued.
 2638	"""
 2639	date: Time!
 2640	status: Status!
 2641}
 2642"""
 2643SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug
 2644"""
 2645type SetStatusTimelineItem implements TimelineItem & Authored {
 2646	"""
 2647	The identifier of the source operation
 2648	"""
 2649	id: String!
 2650	author: Identity!
 2651	date: Time!
 2652	status: Status!
 2653}
 2654input SetTitleInput {
 2655	"""
 2656	A unique identifier for the client performing the mutation.
 2657	"""
 2658	clientMutationId: String
 2659	"""
 2660	"The name of the repository. If not set, the default repository is used.
 2661	"""
 2662	repoRef: String
 2663	"""
 2664	The bug ID's prefix.
 2665	"""
 2666	prefix: String!
 2667	"""
 2668	The new title.
 2669	"""
 2670	title: String!
 2671}
 2672type SetTitleOperation implements Operation & Authored {
 2673	"""
 2674	The identifier of the operation
 2675	"""
 2676	id: String!
 2677	"""
 2678	The author of this object.
 2679	"""
 2680	author: Identity!
 2681	"""
 2682	The datetime when this operation was issued.
 2683	"""
 2684	date: Time!
 2685	title: String!
 2686	was: String!
 2687}
 2688type SetTitlePayload {
 2689	"""
 2690	A unique identifier for the client performing the mutation.
 2691	"""
 2692	clientMutationId: String
 2693	"""
 2694	The affected bug.
 2695	"""
 2696	bug: Bug!
 2697	"""
 2698	The resulting operation
 2699	"""
 2700	operation: SetTitleOperation!
 2701}
 2702"""
 2703LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug
 2704"""
 2705type SetTitleTimelineItem implements TimelineItem & Authored {
 2706	"""
 2707	The identifier of the source operation
 2708	"""
 2709	id: String!
 2710	author: Identity!
 2711	date: Time!
 2712	title: String!
 2713	was: String!
 2714}
 2715enum Status {
 2716	OPEN
 2717	CLOSED
 2718}
 2719scalar Time
 2720"""
 2721An item in the timeline of events
 2722"""
 2723interface TimelineItem {
 2724	"""
 2725	The identifier of the source operation
 2726	"""
 2727	id: String!
 2728}
 2729"""
 2730The connection type for TimelineItem
 2731"""
 2732type TimelineItemConnection {
 2733	edges: [TimelineItemEdge!]!
 2734	nodes: [TimelineItem!]!
 2735	pageInfo: PageInfo!
 2736	totalCount: Int!
 2737}
 2738"""
 2739Represent a TimelineItem
 2740"""
 2741type TimelineItemEdge {
 2742	cursor: String!
 2743	node: TimelineItem!
 2744}
 2745`},
 2746)
 2747
 2748// endregion ************************** generated!.gotpl **************************
 2749
 2750// region    ***************************** args.gotpl *****************************
 2751
 2752func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2753	var err error
 2754	args := map[string]interface{}{}
 2755	var arg0 *string
 2756	if tmp, ok := rawArgs["after"]; ok {
 2757		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2758		if err != nil {
 2759			return nil, err
 2760		}
 2761	}
 2762	args["after"] = arg0
 2763	var arg1 *string
 2764	if tmp, ok := rawArgs["before"]; ok {
 2765		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2766		if err != nil {
 2767			return nil, err
 2768		}
 2769	}
 2770	args["before"] = arg1
 2771	var arg2 *int
 2772	if tmp, ok := rawArgs["first"]; ok {
 2773		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2774		if err != nil {
 2775			return nil, err
 2776		}
 2777	}
 2778	args["first"] = arg2
 2779	var arg3 *int
 2780	if tmp, ok := rawArgs["last"]; ok {
 2781		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2782		if err != nil {
 2783			return nil, err
 2784		}
 2785	}
 2786	args["last"] = arg3
 2787	return args, nil
 2788}
 2789
 2790func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2791	var err error
 2792	args := map[string]interface{}{}
 2793	var arg0 *string
 2794	if tmp, ok := rawArgs["after"]; ok {
 2795		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2796		if err != nil {
 2797			return nil, err
 2798		}
 2799	}
 2800	args["after"] = arg0
 2801	var arg1 *string
 2802	if tmp, ok := rawArgs["before"]; ok {
 2803		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2804		if err != nil {
 2805			return nil, err
 2806		}
 2807	}
 2808	args["before"] = arg1
 2809	var arg2 *int
 2810	if tmp, ok := rawArgs["first"]; ok {
 2811		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2812		if err != nil {
 2813			return nil, err
 2814		}
 2815	}
 2816	args["first"] = arg2
 2817	var arg3 *int
 2818	if tmp, ok := rawArgs["last"]; ok {
 2819		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2820		if err != nil {
 2821			return nil, err
 2822		}
 2823	}
 2824	args["last"] = arg3
 2825	return args, nil
 2826}
 2827
 2828func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2829	var err error
 2830	args := map[string]interface{}{}
 2831	var arg0 *string
 2832	if tmp, ok := rawArgs["after"]; ok {
 2833		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2834		if err != nil {
 2835			return nil, err
 2836		}
 2837	}
 2838	args["after"] = arg0
 2839	var arg1 *string
 2840	if tmp, ok := rawArgs["before"]; ok {
 2841		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2842		if err != nil {
 2843			return nil, err
 2844		}
 2845	}
 2846	args["before"] = arg1
 2847	var arg2 *int
 2848	if tmp, ok := rawArgs["first"]; ok {
 2849		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2850		if err != nil {
 2851			return nil, err
 2852		}
 2853	}
 2854	args["first"] = arg2
 2855	var arg3 *int
 2856	if tmp, ok := rawArgs["last"]; ok {
 2857		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2858		if err != nil {
 2859			return nil, err
 2860		}
 2861	}
 2862	args["last"] = arg3
 2863	return args, nil
 2864}
 2865
 2866func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2867	var err error
 2868	args := map[string]interface{}{}
 2869	var arg0 *string
 2870	if tmp, ok := rawArgs["after"]; ok {
 2871		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2872		if err != nil {
 2873			return nil, err
 2874		}
 2875	}
 2876	args["after"] = arg0
 2877	var arg1 *string
 2878	if tmp, ok := rawArgs["before"]; ok {
 2879		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2880		if err != nil {
 2881			return nil, err
 2882		}
 2883	}
 2884	args["before"] = arg1
 2885	var arg2 *int
 2886	if tmp, ok := rawArgs["first"]; ok {
 2887		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2888		if err != nil {
 2889			return nil, err
 2890		}
 2891	}
 2892	args["first"] = arg2
 2893	var arg3 *int
 2894	if tmp, ok := rawArgs["last"]; ok {
 2895		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2896		if err != nil {
 2897			return nil, err
 2898		}
 2899	}
 2900	args["last"] = arg3
 2901	return args, nil
 2902}
 2903
 2904func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2905	var err error
 2906	args := map[string]interface{}{}
 2907	var arg0 *string
 2908	if tmp, ok := rawArgs["after"]; ok {
 2909		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2910		if err != nil {
 2911			return nil, err
 2912		}
 2913	}
 2914	args["after"] = arg0
 2915	var arg1 *string
 2916	if tmp, ok := rawArgs["before"]; ok {
 2917		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2918		if err != nil {
 2919			return nil, err
 2920		}
 2921	}
 2922	args["before"] = arg1
 2923	var arg2 *int
 2924	if tmp, ok := rawArgs["first"]; ok {
 2925		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2926		if err != nil {
 2927			return nil, err
 2928		}
 2929	}
 2930	args["first"] = arg2
 2931	var arg3 *int
 2932	if tmp, ok := rawArgs["last"]; ok {
 2933		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2934		if err != nil {
 2935			return nil, err
 2936		}
 2937	}
 2938	args["last"] = arg3
 2939	return args, nil
 2940}
 2941
 2942func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2943	var err error
 2944	args := map[string]interface{}{}
 2945	var arg0 models.AddCommentInput
 2946	if tmp, ok := rawArgs["input"]; ok {
 2947		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2948		if err != nil {
 2949			return nil, err
 2950		}
 2951	}
 2952	args["input"] = arg0
 2953	return args, nil
 2954}
 2955
 2956func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2957	var err error
 2958	args := map[string]interface{}{}
 2959	var arg0 *models.ChangeLabelInput
 2960	if tmp, ok := rawArgs["input"]; ok {
 2961		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2962		if err != nil {
 2963			return nil, err
 2964		}
 2965	}
 2966	args["input"] = arg0
 2967	return args, nil
 2968}
 2969
 2970func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2971	var err error
 2972	args := map[string]interface{}{}
 2973	var arg0 models.CloseBugInput
 2974	if tmp, ok := rawArgs["input"]; ok {
 2975		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2976		if err != nil {
 2977			return nil, err
 2978		}
 2979	}
 2980	args["input"] = arg0
 2981	return args, nil
 2982}
 2983
 2984func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2985	var err error
 2986	args := map[string]interface{}{}
 2987	var arg0 models.CommitAsNeededInput
 2988	if tmp, ok := rawArgs["input"]; ok {
 2989		arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
 2990		if err != nil {
 2991			return nil, err
 2992		}
 2993	}
 2994	args["input"] = arg0
 2995	return args, nil
 2996}
 2997
 2998func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2999	var err error
 3000	args := map[string]interface{}{}
 3001	var arg0 models.CommitInput
 3002	if tmp, ok := rawArgs["input"]; ok {
 3003		arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
 3004		if err != nil {
 3005			return nil, err
 3006		}
 3007	}
 3008	args["input"] = arg0
 3009	return args, nil
 3010}
 3011
 3012func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3013	var err error
 3014	args := map[string]interface{}{}
 3015	var arg0 models.NewBugInput
 3016	if tmp, ok := rawArgs["input"]; ok {
 3017		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 3018		if err != nil {
 3019			return nil, err
 3020		}
 3021	}
 3022	args["input"] = arg0
 3023	return args, nil
 3024}
 3025
 3026func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3027	var err error
 3028	args := map[string]interface{}{}
 3029	var arg0 models.OpenBugInput
 3030	if tmp, ok := rawArgs["input"]; ok {
 3031		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 3032		if err != nil {
 3033			return nil, err
 3034		}
 3035	}
 3036	args["input"] = arg0
 3037	return args, nil
 3038}
 3039
 3040func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3041	var err error
 3042	args := map[string]interface{}{}
 3043	var arg0 models.SetTitleInput
 3044	if tmp, ok := rawArgs["input"]; ok {
 3045		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 3046		if err != nil {
 3047			return nil, err
 3048		}
 3049	}
 3050	args["input"] = arg0
 3051	return args, nil
 3052}
 3053
 3054func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3055	var err error
 3056	args := map[string]interface{}{}
 3057	var arg0 string
 3058	if tmp, ok := rawArgs["name"]; ok {
 3059		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 3060		if err != nil {
 3061			return nil, err
 3062		}
 3063	}
 3064	args["name"] = arg0
 3065	return args, nil
 3066}
 3067
 3068func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3069	var err error
 3070	args := map[string]interface{}{}
 3071	var arg0 string
 3072	if tmp, ok := rawArgs["ref"]; ok {
 3073		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 3074		if err != nil {
 3075			return nil, err
 3076		}
 3077	}
 3078	args["ref"] = arg0
 3079	return args, nil
 3080}
 3081
 3082func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3083	var err error
 3084	args := map[string]interface{}{}
 3085	var arg0 *string
 3086	if tmp, ok := rawArgs["after"]; ok {
 3087		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3088		if err != nil {
 3089			return nil, err
 3090		}
 3091	}
 3092	args["after"] = arg0
 3093	var arg1 *string
 3094	if tmp, ok := rawArgs["before"]; ok {
 3095		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3096		if err != nil {
 3097			return nil, err
 3098		}
 3099	}
 3100	args["before"] = arg1
 3101	var arg2 *int
 3102	if tmp, ok := rawArgs["first"]; ok {
 3103		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3104		if err != nil {
 3105			return nil, err
 3106		}
 3107	}
 3108	args["first"] = arg2
 3109	var arg3 *int
 3110	if tmp, ok := rawArgs["last"]; ok {
 3111		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3112		if err != nil {
 3113			return nil, err
 3114		}
 3115	}
 3116	args["last"] = arg3
 3117	var arg4 *string
 3118	if tmp, ok := rawArgs["query"]; ok {
 3119		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3120		if err != nil {
 3121			return nil, err
 3122		}
 3123	}
 3124	args["query"] = arg4
 3125	return args, nil
 3126}
 3127
 3128func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3129	var err error
 3130	args := map[string]interface{}{}
 3131	var arg0 *string
 3132	if tmp, ok := rawArgs["after"]; ok {
 3133		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3134		if err != nil {
 3135			return nil, err
 3136		}
 3137	}
 3138	args["after"] = arg0
 3139	var arg1 *string
 3140	if tmp, ok := rawArgs["before"]; ok {
 3141		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3142		if err != nil {
 3143			return nil, err
 3144		}
 3145	}
 3146	args["before"] = arg1
 3147	var arg2 *int
 3148	if tmp, ok := rawArgs["first"]; ok {
 3149		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3150		if err != nil {
 3151			return nil, err
 3152		}
 3153	}
 3154	args["first"] = arg2
 3155	var arg3 *int
 3156	if tmp, ok := rawArgs["last"]; ok {
 3157		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3158		if err != nil {
 3159			return nil, err
 3160		}
 3161	}
 3162	args["last"] = arg3
 3163	return args, nil
 3164}
 3165
 3166func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3167	var err error
 3168	args := map[string]interface{}{}
 3169	var arg0 string
 3170	if tmp, ok := rawArgs["prefix"]; ok {
 3171		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 3172		if err != nil {
 3173			return nil, err
 3174		}
 3175	}
 3176	args["prefix"] = arg0
 3177	return args, nil
 3178}
 3179
 3180func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3181	var err error
 3182	args := map[string]interface{}{}
 3183	var arg0 string
 3184	if tmp, ok := rawArgs["prefix"]; ok {
 3185		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 3186		if err != nil {
 3187			return nil, err
 3188		}
 3189	}
 3190	args["prefix"] = arg0
 3191	return args, nil
 3192}
 3193
 3194func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3195	var err error
 3196	args := map[string]interface{}{}
 3197	var arg0 *string
 3198	if tmp, ok := rawArgs["after"]; ok {
 3199		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3200		if err != nil {
 3201			return nil, err
 3202		}
 3203	}
 3204	args["after"] = arg0
 3205	var arg1 *string
 3206	if tmp, ok := rawArgs["before"]; ok {
 3207		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 3208		if err != nil {
 3209			return nil, err
 3210		}
 3211	}
 3212	args["before"] = arg1
 3213	var arg2 *int
 3214	if tmp, ok := rawArgs["first"]; ok {
 3215		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3216		if err != nil {
 3217			return nil, err
 3218		}
 3219	}
 3220	args["first"] = arg2
 3221	var arg3 *int
 3222	if tmp, ok := rawArgs["last"]; ok {
 3223		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 3224		if err != nil {
 3225			return nil, err
 3226		}
 3227	}
 3228	args["last"] = arg3
 3229	return args, nil
 3230}
 3231
 3232func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3233	var err error
 3234	args := map[string]interface{}{}
 3235	var arg0 bool
 3236	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 3237		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 3238		if err != nil {
 3239			return nil, err
 3240		}
 3241	}
 3242	args["includeDeprecated"] = arg0
 3243	return args, nil
 3244}
 3245
 3246func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3247	var err error
 3248	args := map[string]interface{}{}
 3249	var arg0 bool
 3250	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 3251		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 3252		if err != nil {
 3253			return nil, err
 3254		}
 3255	}
 3256	args["includeDeprecated"] = arg0
 3257	return args, nil
 3258}
 3259
 3260// endregion ***************************** args.gotpl *****************************
 3261
 3262// region    ************************** directives.gotpl **************************
 3263
 3264// endregion ************************** directives.gotpl **************************
 3265
 3266// region    **************************** field.gotpl *****************************
 3267
 3268func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3269	defer func() {
 3270		if r := recover(); r != nil {
 3271			ec.Error(ctx, ec.Recover(ctx, r))
 3272			ret = graphql.Null
 3273		}
 3274	}()
 3275	fc := &graphql.FieldContext{
 3276		Object:   "AddCommentOperation",
 3277		Field:    field,
 3278		Args:     nil,
 3279		IsMethod: true,
 3280	}
 3281
 3282	ctx = graphql.WithFieldContext(ctx, fc)
 3283	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3284		ctx = rctx // use context from middleware stack in children
 3285		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 3286	})
 3287	if err != nil {
 3288		ec.Error(ctx, err)
 3289		return graphql.Null
 3290	}
 3291	if resTmp == nil {
 3292		if !graphql.HasFieldError(ctx, fc) {
 3293			ec.Errorf(ctx, "must not be null")
 3294		}
 3295		return graphql.Null
 3296	}
 3297	res := resTmp.(string)
 3298	fc.Result = res
 3299	return ec.marshalNString2string(ctx, field.Selections, res)
 3300}
 3301
 3302func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3303	defer func() {
 3304		if r := recover(); r != nil {
 3305			ec.Error(ctx, ec.Recover(ctx, r))
 3306			ret = graphql.Null
 3307		}
 3308	}()
 3309	fc := &graphql.FieldContext{
 3310		Object:   "AddCommentOperation",
 3311		Field:    field,
 3312		Args:     nil,
 3313		IsMethod: false,
 3314	}
 3315
 3316	ctx = graphql.WithFieldContext(ctx, fc)
 3317	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3318		ctx = rctx // use context from middleware stack in children
 3319		return obj.Author, nil
 3320	})
 3321	if err != nil {
 3322		ec.Error(ctx, err)
 3323		return graphql.Null
 3324	}
 3325	if resTmp == nil {
 3326		if !graphql.HasFieldError(ctx, fc) {
 3327			ec.Errorf(ctx, "must not be null")
 3328		}
 3329		return graphql.Null
 3330	}
 3331	res := resTmp.(identity.Interface)
 3332	fc.Result = res
 3333	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3334}
 3335
 3336func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3337	defer func() {
 3338		if r := recover(); r != nil {
 3339			ec.Error(ctx, ec.Recover(ctx, r))
 3340			ret = graphql.Null
 3341		}
 3342	}()
 3343	fc := &graphql.FieldContext{
 3344		Object:   "AddCommentOperation",
 3345		Field:    field,
 3346		Args:     nil,
 3347		IsMethod: true,
 3348	}
 3349
 3350	ctx = graphql.WithFieldContext(ctx, fc)
 3351	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3352		ctx = rctx // use context from middleware stack in children
 3353		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 3354	})
 3355	if err != nil {
 3356		ec.Error(ctx, err)
 3357		return graphql.Null
 3358	}
 3359	if resTmp == nil {
 3360		if !graphql.HasFieldError(ctx, fc) {
 3361			ec.Errorf(ctx, "must not be null")
 3362		}
 3363		return graphql.Null
 3364	}
 3365	res := resTmp.(*time.Time)
 3366	fc.Result = res
 3367	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3368}
 3369
 3370func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3371	defer func() {
 3372		if r := recover(); r != nil {
 3373			ec.Error(ctx, ec.Recover(ctx, r))
 3374			ret = graphql.Null
 3375		}
 3376	}()
 3377	fc := &graphql.FieldContext{
 3378		Object:   "AddCommentOperation",
 3379		Field:    field,
 3380		Args:     nil,
 3381		IsMethod: false,
 3382	}
 3383
 3384	ctx = graphql.WithFieldContext(ctx, fc)
 3385	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3386		ctx = rctx // use context from middleware stack in children
 3387		return obj.Message, nil
 3388	})
 3389	if err != nil {
 3390		ec.Error(ctx, err)
 3391		return graphql.Null
 3392	}
 3393	if resTmp == nil {
 3394		if !graphql.HasFieldError(ctx, fc) {
 3395			ec.Errorf(ctx, "must not be null")
 3396		}
 3397		return graphql.Null
 3398	}
 3399	res := resTmp.(string)
 3400	fc.Result = res
 3401	return ec.marshalNString2string(ctx, field.Selections, res)
 3402}
 3403
 3404func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3405	defer func() {
 3406		if r := recover(); r != nil {
 3407			ec.Error(ctx, ec.Recover(ctx, r))
 3408			ret = graphql.Null
 3409		}
 3410	}()
 3411	fc := &graphql.FieldContext{
 3412		Object:   "AddCommentOperation",
 3413		Field:    field,
 3414		Args:     nil,
 3415		IsMethod: false,
 3416	}
 3417
 3418	ctx = graphql.WithFieldContext(ctx, fc)
 3419	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3420		ctx = rctx // use context from middleware stack in children
 3421		return obj.Files, nil
 3422	})
 3423	if err != nil {
 3424		ec.Error(ctx, err)
 3425		return graphql.Null
 3426	}
 3427	if resTmp == nil {
 3428		if !graphql.HasFieldError(ctx, fc) {
 3429			ec.Errorf(ctx, "must not be null")
 3430		}
 3431		return graphql.Null
 3432	}
 3433	res := resTmp.([]git.Hash)
 3434	fc.Result = res
 3435	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3436}
 3437
 3438func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3439	defer func() {
 3440		if r := recover(); r != nil {
 3441			ec.Error(ctx, ec.Recover(ctx, r))
 3442			ret = graphql.Null
 3443		}
 3444	}()
 3445	fc := &graphql.FieldContext{
 3446		Object:   "AddCommentPayload",
 3447		Field:    field,
 3448		Args:     nil,
 3449		IsMethod: false,
 3450	}
 3451
 3452	ctx = graphql.WithFieldContext(ctx, fc)
 3453	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3454		ctx = rctx // use context from middleware stack in children
 3455		return obj.ClientMutationID, nil
 3456	})
 3457	if err != nil {
 3458		ec.Error(ctx, err)
 3459		return graphql.Null
 3460	}
 3461	if resTmp == nil {
 3462		return graphql.Null
 3463	}
 3464	res := resTmp.(*string)
 3465	fc.Result = res
 3466	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3467}
 3468
 3469func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3470	defer func() {
 3471		if r := recover(); r != nil {
 3472			ec.Error(ctx, ec.Recover(ctx, r))
 3473			ret = graphql.Null
 3474		}
 3475	}()
 3476	fc := &graphql.FieldContext{
 3477		Object:   "AddCommentPayload",
 3478		Field:    field,
 3479		Args:     nil,
 3480		IsMethod: false,
 3481	}
 3482
 3483	ctx = graphql.WithFieldContext(ctx, fc)
 3484	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3485		ctx = rctx // use context from middleware stack in children
 3486		return obj.Bug, nil
 3487	})
 3488	if err != nil {
 3489		ec.Error(ctx, err)
 3490		return graphql.Null
 3491	}
 3492	if resTmp == nil {
 3493		if !graphql.HasFieldError(ctx, fc) {
 3494			ec.Errorf(ctx, "must not be null")
 3495		}
 3496		return graphql.Null
 3497	}
 3498	res := resTmp.(*bug.Snapshot)
 3499	fc.Result = res
 3500	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3501}
 3502
 3503func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3504	defer func() {
 3505		if r := recover(); r != nil {
 3506			ec.Error(ctx, ec.Recover(ctx, r))
 3507			ret = graphql.Null
 3508		}
 3509	}()
 3510	fc := &graphql.FieldContext{
 3511		Object:   "AddCommentPayload",
 3512		Field:    field,
 3513		Args:     nil,
 3514		IsMethod: false,
 3515	}
 3516
 3517	ctx = graphql.WithFieldContext(ctx, fc)
 3518	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3519		ctx = rctx // use context from middleware stack in children
 3520		return obj.Operation, nil
 3521	})
 3522	if err != nil {
 3523		ec.Error(ctx, err)
 3524		return graphql.Null
 3525	}
 3526	if resTmp == nil {
 3527		if !graphql.HasFieldError(ctx, fc) {
 3528			ec.Errorf(ctx, "must not be null")
 3529		}
 3530		return graphql.Null
 3531	}
 3532	res := resTmp.(*bug.AddCommentOperation)
 3533	fc.Result = res
 3534	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3535}
 3536
 3537func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3538	defer func() {
 3539		if r := recover(); r != nil {
 3540			ec.Error(ctx, ec.Recover(ctx, r))
 3541			ret = graphql.Null
 3542		}
 3543	}()
 3544	fc := &graphql.FieldContext{
 3545		Object:   "AddCommentTimelineItem",
 3546		Field:    field,
 3547		Args:     nil,
 3548		IsMethod: true,
 3549	}
 3550
 3551	ctx = graphql.WithFieldContext(ctx, fc)
 3552	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3553		ctx = rctx // use context from middleware stack in children
 3554		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3555	})
 3556	if err != nil {
 3557		ec.Error(ctx, err)
 3558		return graphql.Null
 3559	}
 3560	if resTmp == nil {
 3561		if !graphql.HasFieldError(ctx, fc) {
 3562			ec.Errorf(ctx, "must not be null")
 3563		}
 3564		return graphql.Null
 3565	}
 3566	res := resTmp.(string)
 3567	fc.Result = res
 3568	return ec.marshalNString2string(ctx, field.Selections, res)
 3569}
 3570
 3571func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3572	defer func() {
 3573		if r := recover(); r != nil {
 3574			ec.Error(ctx, ec.Recover(ctx, r))
 3575			ret = graphql.Null
 3576		}
 3577	}()
 3578	fc := &graphql.FieldContext{
 3579		Object:   "AddCommentTimelineItem",
 3580		Field:    field,
 3581		Args:     nil,
 3582		IsMethod: false,
 3583	}
 3584
 3585	ctx = graphql.WithFieldContext(ctx, fc)
 3586	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3587		ctx = rctx // use context from middleware stack in children
 3588		return obj.Author, nil
 3589	})
 3590	if err != nil {
 3591		ec.Error(ctx, err)
 3592		return graphql.Null
 3593	}
 3594	if resTmp == nil {
 3595		if !graphql.HasFieldError(ctx, fc) {
 3596			ec.Errorf(ctx, "must not be null")
 3597		}
 3598		return graphql.Null
 3599	}
 3600	res := resTmp.(identity.Interface)
 3601	fc.Result = res
 3602	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3603}
 3604
 3605func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3606	defer func() {
 3607		if r := recover(); r != nil {
 3608			ec.Error(ctx, ec.Recover(ctx, r))
 3609			ret = graphql.Null
 3610		}
 3611	}()
 3612	fc := &graphql.FieldContext{
 3613		Object:   "AddCommentTimelineItem",
 3614		Field:    field,
 3615		Args:     nil,
 3616		IsMethod: false,
 3617	}
 3618
 3619	ctx = graphql.WithFieldContext(ctx, fc)
 3620	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3621		ctx = rctx // use context from middleware stack in children
 3622		return obj.Message, nil
 3623	})
 3624	if err != nil {
 3625		ec.Error(ctx, err)
 3626		return graphql.Null
 3627	}
 3628	if resTmp == nil {
 3629		if !graphql.HasFieldError(ctx, fc) {
 3630			ec.Errorf(ctx, "must not be null")
 3631		}
 3632		return graphql.Null
 3633	}
 3634	res := resTmp.(string)
 3635	fc.Result = res
 3636	return ec.marshalNString2string(ctx, field.Selections, res)
 3637}
 3638
 3639func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3640	defer func() {
 3641		if r := recover(); r != nil {
 3642			ec.Error(ctx, ec.Recover(ctx, r))
 3643			ret = graphql.Null
 3644		}
 3645	}()
 3646	fc := &graphql.FieldContext{
 3647		Object:   "AddCommentTimelineItem",
 3648		Field:    field,
 3649		Args:     nil,
 3650		IsMethod: true,
 3651	}
 3652
 3653	ctx = graphql.WithFieldContext(ctx, fc)
 3654	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3655		ctx = rctx // use context from middleware stack in children
 3656		return obj.MessageIsEmpty(), nil
 3657	})
 3658	if err != nil {
 3659		ec.Error(ctx, err)
 3660		return graphql.Null
 3661	}
 3662	if resTmp == nil {
 3663		if !graphql.HasFieldError(ctx, fc) {
 3664			ec.Errorf(ctx, "must not be null")
 3665		}
 3666		return graphql.Null
 3667	}
 3668	res := resTmp.(bool)
 3669	fc.Result = res
 3670	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3671}
 3672
 3673func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3674	defer func() {
 3675		if r := recover(); r != nil {
 3676			ec.Error(ctx, ec.Recover(ctx, r))
 3677			ret = graphql.Null
 3678		}
 3679	}()
 3680	fc := &graphql.FieldContext{
 3681		Object:   "AddCommentTimelineItem",
 3682		Field:    field,
 3683		Args:     nil,
 3684		IsMethod: false,
 3685	}
 3686
 3687	ctx = graphql.WithFieldContext(ctx, fc)
 3688	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3689		ctx = rctx // use context from middleware stack in children
 3690		return obj.Files, nil
 3691	})
 3692	if err != nil {
 3693		ec.Error(ctx, err)
 3694		return graphql.Null
 3695	}
 3696	if resTmp == nil {
 3697		if !graphql.HasFieldError(ctx, fc) {
 3698			ec.Errorf(ctx, "must not be null")
 3699		}
 3700		return graphql.Null
 3701	}
 3702	res := resTmp.([]git.Hash)
 3703	fc.Result = res
 3704	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3705}
 3706
 3707func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3708	defer func() {
 3709		if r := recover(); r != nil {
 3710			ec.Error(ctx, ec.Recover(ctx, r))
 3711			ret = graphql.Null
 3712		}
 3713	}()
 3714	fc := &graphql.FieldContext{
 3715		Object:   "AddCommentTimelineItem",
 3716		Field:    field,
 3717		Args:     nil,
 3718		IsMethod: true,
 3719	}
 3720
 3721	ctx = graphql.WithFieldContext(ctx, fc)
 3722	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3723		ctx = rctx // use context from middleware stack in children
 3724		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3725	})
 3726	if err != nil {
 3727		ec.Error(ctx, err)
 3728		return graphql.Null
 3729	}
 3730	if resTmp == nil {
 3731		if !graphql.HasFieldError(ctx, fc) {
 3732			ec.Errorf(ctx, "must not be null")
 3733		}
 3734		return graphql.Null
 3735	}
 3736	res := resTmp.(*time.Time)
 3737	fc.Result = res
 3738	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3739}
 3740
 3741func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3742	defer func() {
 3743		if r := recover(); r != nil {
 3744			ec.Error(ctx, ec.Recover(ctx, r))
 3745			ret = graphql.Null
 3746		}
 3747	}()
 3748	fc := &graphql.FieldContext{
 3749		Object:   "AddCommentTimelineItem",
 3750		Field:    field,
 3751		Args:     nil,
 3752		IsMethod: true,
 3753	}
 3754
 3755	ctx = graphql.WithFieldContext(ctx, fc)
 3756	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3757		ctx = rctx // use context from middleware stack in children
 3758		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3759	})
 3760	if err != nil {
 3761		ec.Error(ctx, err)
 3762		return graphql.Null
 3763	}
 3764	if resTmp == nil {
 3765		if !graphql.HasFieldError(ctx, fc) {
 3766			ec.Errorf(ctx, "must not be null")
 3767		}
 3768		return graphql.Null
 3769	}
 3770	res := resTmp.(*time.Time)
 3771	fc.Result = res
 3772	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3773}
 3774
 3775func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3776	defer func() {
 3777		if r := recover(); r != nil {
 3778			ec.Error(ctx, ec.Recover(ctx, r))
 3779			ret = graphql.Null
 3780		}
 3781	}()
 3782	fc := &graphql.FieldContext{
 3783		Object:   "AddCommentTimelineItem",
 3784		Field:    field,
 3785		Args:     nil,
 3786		IsMethod: true,
 3787	}
 3788
 3789	ctx = graphql.WithFieldContext(ctx, fc)
 3790	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3791		ctx = rctx // use context from middleware stack in children
 3792		return obj.Edited(), nil
 3793	})
 3794	if err != nil {
 3795		ec.Error(ctx, err)
 3796		return graphql.Null
 3797	}
 3798	if resTmp == nil {
 3799		if !graphql.HasFieldError(ctx, fc) {
 3800			ec.Errorf(ctx, "must not be null")
 3801		}
 3802		return graphql.Null
 3803	}
 3804	res := resTmp.(bool)
 3805	fc.Result = res
 3806	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3807}
 3808
 3809func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3810	defer func() {
 3811		if r := recover(); r != nil {
 3812			ec.Error(ctx, ec.Recover(ctx, r))
 3813			ret = graphql.Null
 3814		}
 3815	}()
 3816	fc := &graphql.FieldContext{
 3817		Object:   "AddCommentTimelineItem",
 3818		Field:    field,
 3819		Args:     nil,
 3820		IsMethod: false,
 3821	}
 3822
 3823	ctx = graphql.WithFieldContext(ctx, fc)
 3824	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3825		ctx = rctx // use context from middleware stack in children
 3826		return obj.History, nil
 3827	})
 3828	if err != nil {
 3829		ec.Error(ctx, err)
 3830		return graphql.Null
 3831	}
 3832	if resTmp == nil {
 3833		if !graphql.HasFieldError(ctx, fc) {
 3834			ec.Errorf(ctx, "must not be null")
 3835		}
 3836		return graphql.Null
 3837	}
 3838	res := resTmp.([]bug.CommentHistoryStep)
 3839	fc.Result = res
 3840	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3841}
 3842
 3843func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3844	defer func() {
 3845		if r := recover(); r != nil {
 3846			ec.Error(ctx, ec.Recover(ctx, r))
 3847			ret = graphql.Null
 3848		}
 3849	}()
 3850	fc := &graphql.FieldContext{
 3851		Object:   "Bug",
 3852		Field:    field,
 3853		Args:     nil,
 3854		IsMethod: true,
 3855	}
 3856
 3857	ctx = graphql.WithFieldContext(ctx, fc)
 3858	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3859		ctx = rctx // use context from middleware stack in children
 3860		return ec.resolvers.Bug().ID(rctx, obj)
 3861	})
 3862	if err != nil {
 3863		ec.Error(ctx, err)
 3864		return graphql.Null
 3865	}
 3866	if resTmp == nil {
 3867		if !graphql.HasFieldError(ctx, fc) {
 3868			ec.Errorf(ctx, "must not be null")
 3869		}
 3870		return graphql.Null
 3871	}
 3872	res := resTmp.(string)
 3873	fc.Result = res
 3874	return ec.marshalNString2string(ctx, field.Selections, res)
 3875}
 3876
 3877func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3878	defer func() {
 3879		if r := recover(); r != nil {
 3880			ec.Error(ctx, ec.Recover(ctx, r))
 3881			ret = graphql.Null
 3882		}
 3883	}()
 3884	fc := &graphql.FieldContext{
 3885		Object:   "Bug",
 3886		Field:    field,
 3887		Args:     nil,
 3888		IsMethod: true,
 3889	}
 3890
 3891	ctx = graphql.WithFieldContext(ctx, fc)
 3892	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3893		ctx = rctx // use context from middleware stack in children
 3894		return ec.resolvers.Bug().HumanID(rctx, obj)
 3895	})
 3896	if err != nil {
 3897		ec.Error(ctx, err)
 3898		return graphql.Null
 3899	}
 3900	if resTmp == nil {
 3901		if !graphql.HasFieldError(ctx, fc) {
 3902			ec.Errorf(ctx, "must not be null")
 3903		}
 3904		return graphql.Null
 3905	}
 3906	res := resTmp.(string)
 3907	fc.Result = res
 3908	return ec.marshalNString2string(ctx, field.Selections, res)
 3909}
 3910
 3911func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3912	defer func() {
 3913		if r := recover(); r != nil {
 3914			ec.Error(ctx, ec.Recover(ctx, r))
 3915			ret = graphql.Null
 3916		}
 3917	}()
 3918	fc := &graphql.FieldContext{
 3919		Object:   "Bug",
 3920		Field:    field,
 3921		Args:     nil,
 3922		IsMethod: true,
 3923	}
 3924
 3925	ctx = graphql.WithFieldContext(ctx, fc)
 3926	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3927		ctx = rctx // use context from middleware stack in children
 3928		return ec.resolvers.Bug().Status(rctx, obj)
 3929	})
 3930	if err != nil {
 3931		ec.Error(ctx, err)
 3932		return graphql.Null
 3933	}
 3934	if resTmp == nil {
 3935		if !graphql.HasFieldError(ctx, fc) {
 3936			ec.Errorf(ctx, "must not be null")
 3937		}
 3938		return graphql.Null
 3939	}
 3940	res := resTmp.(models.Status)
 3941	fc.Result = res
 3942	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3943}
 3944
 3945func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3946	defer func() {
 3947		if r := recover(); r != nil {
 3948			ec.Error(ctx, ec.Recover(ctx, r))
 3949			ret = graphql.Null
 3950		}
 3951	}()
 3952	fc := &graphql.FieldContext{
 3953		Object:   "Bug",
 3954		Field:    field,
 3955		Args:     nil,
 3956		IsMethod: false,
 3957	}
 3958
 3959	ctx = graphql.WithFieldContext(ctx, fc)
 3960	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3961		ctx = rctx // use context from middleware stack in children
 3962		return obj.Title, nil
 3963	})
 3964	if err != nil {
 3965		ec.Error(ctx, err)
 3966		return graphql.Null
 3967	}
 3968	if resTmp == nil {
 3969		if !graphql.HasFieldError(ctx, fc) {
 3970			ec.Errorf(ctx, "must not be null")
 3971		}
 3972		return graphql.Null
 3973	}
 3974	res := resTmp.(string)
 3975	fc.Result = res
 3976	return ec.marshalNString2string(ctx, field.Selections, res)
 3977}
 3978
 3979func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3980	defer func() {
 3981		if r := recover(); r != nil {
 3982			ec.Error(ctx, ec.Recover(ctx, r))
 3983			ret = graphql.Null
 3984		}
 3985	}()
 3986	fc := &graphql.FieldContext{
 3987		Object:   "Bug",
 3988		Field:    field,
 3989		Args:     nil,
 3990		IsMethod: false,
 3991	}
 3992
 3993	ctx = graphql.WithFieldContext(ctx, fc)
 3994	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3995		ctx = rctx // use context from middleware stack in children
 3996		return obj.Labels, nil
 3997	})
 3998	if err != nil {
 3999		ec.Error(ctx, err)
 4000		return graphql.Null
 4001	}
 4002	if resTmp == nil {
 4003		if !graphql.HasFieldError(ctx, fc) {
 4004			ec.Errorf(ctx, "must not be null")
 4005		}
 4006		return graphql.Null
 4007	}
 4008	res := resTmp.([]bug.Label)
 4009	fc.Result = res
 4010	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 4011}
 4012
 4013func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4014	defer func() {
 4015		if r := recover(); r != nil {
 4016			ec.Error(ctx, ec.Recover(ctx, r))
 4017			ret = graphql.Null
 4018		}
 4019	}()
 4020	fc := &graphql.FieldContext{
 4021		Object:   "Bug",
 4022		Field:    field,
 4023		Args:     nil,
 4024		IsMethod: false,
 4025	}
 4026
 4027	ctx = graphql.WithFieldContext(ctx, fc)
 4028	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4029		ctx = rctx // use context from middleware stack in children
 4030		return obj.Author, nil
 4031	})
 4032	if err != nil {
 4033		ec.Error(ctx, err)
 4034		return graphql.Null
 4035	}
 4036	if resTmp == nil {
 4037		if !graphql.HasFieldError(ctx, fc) {
 4038			ec.Errorf(ctx, "must not be null")
 4039		}
 4040		return graphql.Null
 4041	}
 4042	res := resTmp.(identity.Interface)
 4043	fc.Result = res
 4044	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4045}
 4046
 4047func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4048	defer func() {
 4049		if r := recover(); r != nil {
 4050			ec.Error(ctx, ec.Recover(ctx, r))
 4051			ret = graphql.Null
 4052		}
 4053	}()
 4054	fc := &graphql.FieldContext{
 4055		Object:   "Bug",
 4056		Field:    field,
 4057		Args:     nil,
 4058		IsMethod: false,
 4059	}
 4060
 4061	ctx = graphql.WithFieldContext(ctx, fc)
 4062	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4063		ctx = rctx // use context from middleware stack in children
 4064		return obj.CreatedAt, nil
 4065	})
 4066	if err != nil {
 4067		ec.Error(ctx, err)
 4068		return graphql.Null
 4069	}
 4070	if resTmp == nil {
 4071		if !graphql.HasFieldError(ctx, fc) {
 4072			ec.Errorf(ctx, "must not be null")
 4073		}
 4074		return graphql.Null
 4075	}
 4076	res := resTmp.(time.Time)
 4077	fc.Result = res
 4078	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 4079}
 4080
 4081func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4082	defer func() {
 4083		if r := recover(); r != nil {
 4084			ec.Error(ctx, ec.Recover(ctx, r))
 4085			ret = graphql.Null
 4086		}
 4087	}()
 4088	fc := &graphql.FieldContext{
 4089		Object:   "Bug",
 4090		Field:    field,
 4091		Args:     nil,
 4092		IsMethod: true,
 4093	}
 4094
 4095	ctx = graphql.WithFieldContext(ctx, fc)
 4096	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4097		ctx = rctx // use context from middleware stack in children
 4098		return ec.resolvers.Bug().LastEdit(rctx, obj)
 4099	})
 4100	if err != nil {
 4101		ec.Error(ctx, err)
 4102		return graphql.Null
 4103	}
 4104	if resTmp == nil {
 4105		if !graphql.HasFieldError(ctx, fc) {
 4106			ec.Errorf(ctx, "must not be null")
 4107		}
 4108		return graphql.Null
 4109	}
 4110	res := resTmp.(*time.Time)
 4111	fc.Result = res
 4112	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4113}
 4114
 4115func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4116	defer func() {
 4117		if r := recover(); r != nil {
 4118			ec.Error(ctx, ec.Recover(ctx, r))
 4119			ret = graphql.Null
 4120		}
 4121	}()
 4122	fc := &graphql.FieldContext{
 4123		Object:   "Bug",
 4124		Field:    field,
 4125		Args:     nil,
 4126		IsMethod: true,
 4127	}
 4128
 4129	ctx = graphql.WithFieldContext(ctx, fc)
 4130	rawArgs := field.ArgumentMap(ec.Variables)
 4131	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 4132	if err != nil {
 4133		ec.Error(ctx, err)
 4134		return graphql.Null
 4135	}
 4136	fc.Args = args
 4137	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4138		ctx = rctx // use context from middleware stack in children
 4139		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4140	})
 4141	if err != nil {
 4142		ec.Error(ctx, err)
 4143		return graphql.Null
 4144	}
 4145	if resTmp == nil {
 4146		if !graphql.HasFieldError(ctx, fc) {
 4147			ec.Errorf(ctx, "must not be null")
 4148		}
 4149		return graphql.Null
 4150	}
 4151	res := resTmp.(*models.IdentityConnection)
 4152	fc.Result = res
 4153	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 4154}
 4155
 4156func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4157	defer func() {
 4158		if r := recover(); r != nil {
 4159			ec.Error(ctx, ec.Recover(ctx, r))
 4160			ret = graphql.Null
 4161		}
 4162	}()
 4163	fc := &graphql.FieldContext{
 4164		Object:   "Bug",
 4165		Field:    field,
 4166		Args:     nil,
 4167		IsMethod: true,
 4168	}
 4169
 4170	ctx = graphql.WithFieldContext(ctx, fc)
 4171	rawArgs := field.ArgumentMap(ec.Variables)
 4172	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 4173	if err != nil {
 4174		ec.Error(ctx, err)
 4175		return graphql.Null
 4176	}
 4177	fc.Args = args
 4178	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4179		ctx = rctx // use context from middleware stack in children
 4180		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4181	})
 4182	if err != nil {
 4183		ec.Error(ctx, err)
 4184		return graphql.Null
 4185	}
 4186	if resTmp == nil {
 4187		if !graphql.HasFieldError(ctx, fc) {
 4188			ec.Errorf(ctx, "must not be null")
 4189		}
 4190		return graphql.Null
 4191	}
 4192	res := resTmp.(*models.IdentityConnection)
 4193	fc.Result = res
 4194	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 4195}
 4196
 4197func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4198	defer func() {
 4199		if r := recover(); r != nil {
 4200			ec.Error(ctx, ec.Recover(ctx, r))
 4201			ret = graphql.Null
 4202		}
 4203	}()
 4204	fc := &graphql.FieldContext{
 4205		Object:   "Bug",
 4206		Field:    field,
 4207		Args:     nil,
 4208		IsMethod: true,
 4209	}
 4210
 4211	ctx = graphql.WithFieldContext(ctx, fc)
 4212	rawArgs := field.ArgumentMap(ec.Variables)
 4213	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 4214	if err != nil {
 4215		ec.Error(ctx, err)
 4216		return graphql.Null
 4217	}
 4218	fc.Args = args
 4219	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4220		ctx = rctx // use context from middleware stack in children
 4221		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4222	})
 4223	if err != nil {
 4224		ec.Error(ctx, err)
 4225		return graphql.Null
 4226	}
 4227	if resTmp == nil {
 4228		if !graphql.HasFieldError(ctx, fc) {
 4229			ec.Errorf(ctx, "must not be null")
 4230		}
 4231		return graphql.Null
 4232	}
 4233	res := resTmp.(*models.CommentConnection)
 4234	fc.Result = res
 4235	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 4236}
 4237
 4238func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4239	defer func() {
 4240		if r := recover(); r != nil {
 4241			ec.Error(ctx, ec.Recover(ctx, r))
 4242			ret = graphql.Null
 4243		}
 4244	}()
 4245	fc := &graphql.FieldContext{
 4246		Object:   "Bug",
 4247		Field:    field,
 4248		Args:     nil,
 4249		IsMethod: true,
 4250	}
 4251
 4252	ctx = graphql.WithFieldContext(ctx, fc)
 4253	rawArgs := field.ArgumentMap(ec.Variables)
 4254	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 4255	if err != nil {
 4256		ec.Error(ctx, err)
 4257		return graphql.Null
 4258	}
 4259	fc.Args = args
 4260	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4261		ctx = rctx // use context from middleware stack in children
 4262		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4263	})
 4264	if err != nil {
 4265		ec.Error(ctx, err)
 4266		return graphql.Null
 4267	}
 4268	if resTmp == nil {
 4269		if !graphql.HasFieldError(ctx, fc) {
 4270			ec.Errorf(ctx, "must not be null")
 4271		}
 4272		return graphql.Null
 4273	}
 4274	res := resTmp.(*models.TimelineItemConnection)
 4275	fc.Result = res
 4276	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 4277}
 4278
 4279func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4280	defer func() {
 4281		if r := recover(); r != nil {
 4282			ec.Error(ctx, ec.Recover(ctx, r))
 4283			ret = graphql.Null
 4284		}
 4285	}()
 4286	fc := &graphql.FieldContext{
 4287		Object:   "Bug",
 4288		Field:    field,
 4289		Args:     nil,
 4290		IsMethod: true,
 4291	}
 4292
 4293	ctx = graphql.WithFieldContext(ctx, fc)
 4294	rawArgs := field.ArgumentMap(ec.Variables)
 4295	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 4296	if err != nil {
 4297		ec.Error(ctx, err)
 4298		return graphql.Null
 4299	}
 4300	fc.Args = args
 4301	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4302		ctx = rctx // use context from middleware stack in children
 4303		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4304	})
 4305	if err != nil {
 4306		ec.Error(ctx, err)
 4307		return graphql.Null
 4308	}
 4309	if resTmp == nil {
 4310		if !graphql.HasFieldError(ctx, fc) {
 4311			ec.Errorf(ctx, "must not be null")
 4312		}
 4313		return graphql.Null
 4314	}
 4315	res := resTmp.(*models.OperationConnection)
 4316	fc.Result = res
 4317	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 4318}
 4319
 4320func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4321	defer func() {
 4322		if r := recover(); r != nil {
 4323			ec.Error(ctx, ec.Recover(ctx, r))
 4324			ret = graphql.Null
 4325		}
 4326	}()
 4327	fc := &graphql.FieldContext{
 4328		Object:   "BugConnection",
 4329		Field:    field,
 4330		Args:     nil,
 4331		IsMethod: false,
 4332	}
 4333
 4334	ctx = graphql.WithFieldContext(ctx, fc)
 4335	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4336		ctx = rctx // use context from middleware stack in children
 4337		return obj.Edges, nil
 4338	})
 4339	if err != nil {
 4340		ec.Error(ctx, err)
 4341		return graphql.Null
 4342	}
 4343	if resTmp == nil {
 4344		if !graphql.HasFieldError(ctx, fc) {
 4345			ec.Errorf(ctx, "must not be null")
 4346		}
 4347		return graphql.Null
 4348	}
 4349	res := resTmp.([]*models.BugEdge)
 4350	fc.Result = res
 4351	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 4352}
 4353
 4354func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4355	defer func() {
 4356		if r := recover(); r != nil {
 4357			ec.Error(ctx, ec.Recover(ctx, r))
 4358			ret = graphql.Null
 4359		}
 4360	}()
 4361	fc := &graphql.FieldContext{
 4362		Object:   "BugConnection",
 4363		Field:    field,
 4364		Args:     nil,
 4365		IsMethod: false,
 4366	}
 4367
 4368	ctx = graphql.WithFieldContext(ctx, fc)
 4369	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4370		ctx = rctx // use context from middleware stack in children
 4371		return obj.Nodes, nil
 4372	})
 4373	if err != nil {
 4374		ec.Error(ctx, err)
 4375		return graphql.Null
 4376	}
 4377	if resTmp == nil {
 4378		if !graphql.HasFieldError(ctx, fc) {
 4379			ec.Errorf(ctx, "must not be null")
 4380		}
 4381		return graphql.Null
 4382	}
 4383	res := resTmp.([]*bug.Snapshot)
 4384	fc.Result = res
 4385	return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshotᚄ(ctx, field.Selections, res)
 4386}
 4387
 4388func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4389	defer func() {
 4390		if r := recover(); r != nil {
 4391			ec.Error(ctx, ec.Recover(ctx, r))
 4392			ret = graphql.Null
 4393		}
 4394	}()
 4395	fc := &graphql.FieldContext{
 4396		Object:   "BugConnection",
 4397		Field:    field,
 4398		Args:     nil,
 4399		IsMethod: false,
 4400	}
 4401
 4402	ctx = graphql.WithFieldContext(ctx, fc)
 4403	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4404		ctx = rctx // use context from middleware stack in children
 4405		return obj.PageInfo, nil
 4406	})
 4407	if err != nil {
 4408		ec.Error(ctx, err)
 4409		return graphql.Null
 4410	}
 4411	if resTmp == nil {
 4412		if !graphql.HasFieldError(ctx, fc) {
 4413			ec.Errorf(ctx, "must not be null")
 4414		}
 4415		return graphql.Null
 4416	}
 4417	res := resTmp.(*models.PageInfo)
 4418	fc.Result = res
 4419	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4420}
 4421
 4422func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4423	defer func() {
 4424		if r := recover(); r != nil {
 4425			ec.Error(ctx, ec.Recover(ctx, r))
 4426			ret = graphql.Null
 4427		}
 4428	}()
 4429	fc := &graphql.FieldContext{
 4430		Object:   "BugConnection",
 4431		Field:    field,
 4432		Args:     nil,
 4433		IsMethod: false,
 4434	}
 4435
 4436	ctx = graphql.WithFieldContext(ctx, fc)
 4437	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4438		ctx = rctx // use context from middleware stack in children
 4439		return obj.TotalCount, nil
 4440	})
 4441	if err != nil {
 4442		ec.Error(ctx, err)
 4443		return graphql.Null
 4444	}
 4445	if resTmp == nil {
 4446		if !graphql.HasFieldError(ctx, fc) {
 4447			ec.Errorf(ctx, "must not be null")
 4448		}
 4449		return graphql.Null
 4450	}
 4451	res := resTmp.(int)
 4452	fc.Result = res
 4453	return ec.marshalNInt2int(ctx, field.Selections, res)
 4454}
 4455
 4456func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4457	defer func() {
 4458		if r := recover(); r != nil {
 4459			ec.Error(ctx, ec.Recover(ctx, r))
 4460			ret = graphql.Null
 4461		}
 4462	}()
 4463	fc := &graphql.FieldContext{
 4464		Object:   "BugEdge",
 4465		Field:    field,
 4466		Args:     nil,
 4467		IsMethod: false,
 4468	}
 4469
 4470	ctx = graphql.WithFieldContext(ctx, fc)
 4471	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4472		ctx = rctx // use context from middleware stack in children
 4473		return obj.Cursor, nil
 4474	})
 4475	if err != nil {
 4476		ec.Error(ctx, err)
 4477		return graphql.Null
 4478	}
 4479	if resTmp == nil {
 4480		if !graphql.HasFieldError(ctx, fc) {
 4481			ec.Errorf(ctx, "must not be null")
 4482		}
 4483		return graphql.Null
 4484	}
 4485	res := resTmp.(string)
 4486	fc.Result = res
 4487	return ec.marshalNString2string(ctx, field.Selections, res)
 4488}
 4489
 4490func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4491	defer func() {
 4492		if r := recover(); r != nil {
 4493			ec.Error(ctx, ec.Recover(ctx, r))
 4494			ret = graphql.Null
 4495		}
 4496	}()
 4497	fc := &graphql.FieldContext{
 4498		Object:   "BugEdge",
 4499		Field:    field,
 4500		Args:     nil,
 4501		IsMethod: false,
 4502	}
 4503
 4504	ctx = graphql.WithFieldContext(ctx, fc)
 4505	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4506		ctx = rctx // use context from middleware stack in children
 4507		return obj.Node, nil
 4508	})
 4509	if err != nil {
 4510		ec.Error(ctx, err)
 4511		return graphql.Null
 4512	}
 4513	if resTmp == nil {
 4514		if !graphql.HasFieldError(ctx, fc) {
 4515			ec.Errorf(ctx, "must not be null")
 4516		}
 4517		return graphql.Null
 4518	}
 4519	res := resTmp.(*bug.Snapshot)
 4520	fc.Result = res
 4521	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4522}
 4523
 4524func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4525	defer func() {
 4526		if r := recover(); r != nil {
 4527			ec.Error(ctx, ec.Recover(ctx, r))
 4528			ret = graphql.Null
 4529		}
 4530	}()
 4531	fc := &graphql.FieldContext{
 4532		Object:   "ChangeLabelPayload",
 4533		Field:    field,
 4534		Args:     nil,
 4535		IsMethod: false,
 4536	}
 4537
 4538	ctx = graphql.WithFieldContext(ctx, fc)
 4539	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4540		ctx = rctx // use context from middleware stack in children
 4541		return obj.ClientMutationID, nil
 4542	})
 4543	if err != nil {
 4544		ec.Error(ctx, err)
 4545		return graphql.Null
 4546	}
 4547	if resTmp == nil {
 4548		return graphql.Null
 4549	}
 4550	res := resTmp.(*string)
 4551	fc.Result = res
 4552	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4553}
 4554
 4555func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4556	defer func() {
 4557		if r := recover(); r != nil {
 4558			ec.Error(ctx, ec.Recover(ctx, r))
 4559			ret = graphql.Null
 4560		}
 4561	}()
 4562	fc := &graphql.FieldContext{
 4563		Object:   "ChangeLabelPayload",
 4564		Field:    field,
 4565		Args:     nil,
 4566		IsMethod: false,
 4567	}
 4568
 4569	ctx = graphql.WithFieldContext(ctx, fc)
 4570	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4571		ctx = rctx // use context from middleware stack in children
 4572		return obj.Bug, nil
 4573	})
 4574	if err != nil {
 4575		ec.Error(ctx, err)
 4576		return graphql.Null
 4577	}
 4578	if resTmp == nil {
 4579		if !graphql.HasFieldError(ctx, fc) {
 4580			ec.Errorf(ctx, "must not be null")
 4581		}
 4582		return graphql.Null
 4583	}
 4584	res := resTmp.(*bug.Snapshot)
 4585	fc.Result = res
 4586	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4587}
 4588
 4589func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4590	defer func() {
 4591		if r := recover(); r != nil {
 4592			ec.Error(ctx, ec.Recover(ctx, r))
 4593			ret = graphql.Null
 4594		}
 4595	}()
 4596	fc := &graphql.FieldContext{
 4597		Object:   "ChangeLabelPayload",
 4598		Field:    field,
 4599		Args:     nil,
 4600		IsMethod: false,
 4601	}
 4602
 4603	ctx = graphql.WithFieldContext(ctx, fc)
 4604	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4605		ctx = rctx // use context from middleware stack in children
 4606		return obj.Operation, nil
 4607	})
 4608	if err != nil {
 4609		ec.Error(ctx, err)
 4610		return graphql.Null
 4611	}
 4612	if resTmp == nil {
 4613		if !graphql.HasFieldError(ctx, fc) {
 4614			ec.Errorf(ctx, "must not be null")
 4615		}
 4616		return graphql.Null
 4617	}
 4618	res := resTmp.(*bug.LabelChangeOperation)
 4619	fc.Result = res
 4620	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4621}
 4622
 4623func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4624	defer func() {
 4625		if r := recover(); r != nil {
 4626			ec.Error(ctx, ec.Recover(ctx, r))
 4627			ret = graphql.Null
 4628		}
 4629	}()
 4630	fc := &graphql.FieldContext{
 4631		Object:   "ChangeLabelPayload",
 4632		Field:    field,
 4633		Args:     nil,
 4634		IsMethod: false,
 4635	}
 4636
 4637	ctx = graphql.WithFieldContext(ctx, fc)
 4638	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4639		ctx = rctx // use context from middleware stack in children
 4640		return obj.Results, nil
 4641	})
 4642	if err != nil {
 4643		ec.Error(ctx, err)
 4644		return graphql.Null
 4645	}
 4646	if resTmp == nil {
 4647		if !graphql.HasFieldError(ctx, fc) {
 4648			ec.Errorf(ctx, "must not be null")
 4649		}
 4650		return graphql.Null
 4651	}
 4652	res := resTmp.([]*bug.LabelChangeResult)
 4653	fc.Result = res
 4654	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4655}
 4656
 4657func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4658	defer func() {
 4659		if r := recover(); r != nil {
 4660			ec.Error(ctx, ec.Recover(ctx, r))
 4661			ret = graphql.Null
 4662		}
 4663	}()
 4664	fc := &graphql.FieldContext{
 4665		Object:   "CloseBugPayload",
 4666		Field:    field,
 4667		Args:     nil,
 4668		IsMethod: false,
 4669	}
 4670
 4671	ctx = graphql.WithFieldContext(ctx, fc)
 4672	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4673		ctx = rctx // use context from middleware stack in children
 4674		return obj.ClientMutationID, nil
 4675	})
 4676	if err != nil {
 4677		ec.Error(ctx, err)
 4678		return graphql.Null
 4679	}
 4680	if resTmp == nil {
 4681		return graphql.Null
 4682	}
 4683	res := resTmp.(*string)
 4684	fc.Result = res
 4685	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4686}
 4687
 4688func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4689	defer func() {
 4690		if r := recover(); r != nil {
 4691			ec.Error(ctx, ec.Recover(ctx, r))
 4692			ret = graphql.Null
 4693		}
 4694	}()
 4695	fc := &graphql.FieldContext{
 4696		Object:   "CloseBugPayload",
 4697		Field:    field,
 4698		Args:     nil,
 4699		IsMethod: false,
 4700	}
 4701
 4702	ctx = graphql.WithFieldContext(ctx, fc)
 4703	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4704		ctx = rctx // use context from middleware stack in children
 4705		return obj.Bug, nil
 4706	})
 4707	if err != nil {
 4708		ec.Error(ctx, err)
 4709		return graphql.Null
 4710	}
 4711	if resTmp == nil {
 4712		if !graphql.HasFieldError(ctx, fc) {
 4713			ec.Errorf(ctx, "must not be null")
 4714		}
 4715		return graphql.Null
 4716	}
 4717	res := resTmp.(*bug.Snapshot)
 4718	fc.Result = res
 4719	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4720}
 4721
 4722func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4723	defer func() {
 4724		if r := recover(); r != nil {
 4725			ec.Error(ctx, ec.Recover(ctx, r))
 4726			ret = graphql.Null
 4727		}
 4728	}()
 4729	fc := &graphql.FieldContext{
 4730		Object:   "CloseBugPayload",
 4731		Field:    field,
 4732		Args:     nil,
 4733		IsMethod: false,
 4734	}
 4735
 4736	ctx = graphql.WithFieldContext(ctx, fc)
 4737	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4738		ctx = rctx // use context from middleware stack in children
 4739		return obj.Operation, nil
 4740	})
 4741	if err != nil {
 4742		ec.Error(ctx, err)
 4743		return graphql.Null
 4744	}
 4745	if resTmp == nil {
 4746		if !graphql.HasFieldError(ctx, fc) {
 4747			ec.Errorf(ctx, "must not be null")
 4748		}
 4749		return graphql.Null
 4750	}
 4751	res := resTmp.(*bug.SetStatusOperation)
 4752	fc.Result = res
 4753	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4754}
 4755
 4756func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4757	defer func() {
 4758		if r := recover(); r != nil {
 4759			ec.Error(ctx, ec.Recover(ctx, r))
 4760			ret = graphql.Null
 4761		}
 4762	}()
 4763	fc := &graphql.FieldContext{
 4764		Object:   "Color",
 4765		Field:    field,
 4766		Args:     nil,
 4767		IsMethod: true,
 4768	}
 4769
 4770	ctx = graphql.WithFieldContext(ctx, fc)
 4771	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4772		ctx = rctx // use context from middleware stack in children
 4773		return ec.resolvers.Color().R(rctx, obj)
 4774	})
 4775	if err != nil {
 4776		ec.Error(ctx, err)
 4777		return graphql.Null
 4778	}
 4779	if resTmp == nil {
 4780		if !graphql.HasFieldError(ctx, fc) {
 4781			ec.Errorf(ctx, "must not be null")
 4782		}
 4783		return graphql.Null
 4784	}
 4785	res := resTmp.(int)
 4786	fc.Result = res
 4787	return ec.marshalNInt2int(ctx, field.Selections, res)
 4788}
 4789
 4790func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4791	defer func() {
 4792		if r := recover(); r != nil {
 4793			ec.Error(ctx, ec.Recover(ctx, r))
 4794			ret = graphql.Null
 4795		}
 4796	}()
 4797	fc := &graphql.FieldContext{
 4798		Object:   "Color",
 4799		Field:    field,
 4800		Args:     nil,
 4801		IsMethod: true,
 4802	}
 4803
 4804	ctx = graphql.WithFieldContext(ctx, fc)
 4805	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4806		ctx = rctx // use context from middleware stack in children
 4807		return ec.resolvers.Color().G(rctx, obj)
 4808	})
 4809	if err != nil {
 4810		ec.Error(ctx, err)
 4811		return graphql.Null
 4812	}
 4813	if resTmp == nil {
 4814		if !graphql.HasFieldError(ctx, fc) {
 4815			ec.Errorf(ctx, "must not be null")
 4816		}
 4817		return graphql.Null
 4818	}
 4819	res := resTmp.(int)
 4820	fc.Result = res
 4821	return ec.marshalNInt2int(ctx, field.Selections, res)
 4822}
 4823
 4824func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4825	defer func() {
 4826		if r := recover(); r != nil {
 4827			ec.Error(ctx, ec.Recover(ctx, r))
 4828			ret = graphql.Null
 4829		}
 4830	}()
 4831	fc := &graphql.FieldContext{
 4832		Object:   "Color",
 4833		Field:    field,
 4834		Args:     nil,
 4835		IsMethod: true,
 4836	}
 4837
 4838	ctx = graphql.WithFieldContext(ctx, fc)
 4839	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4840		ctx = rctx // use context from middleware stack in children
 4841		return ec.resolvers.Color().B(rctx, obj)
 4842	})
 4843	if err != nil {
 4844		ec.Error(ctx, err)
 4845		return graphql.Null
 4846	}
 4847	if resTmp == nil {
 4848		if !graphql.HasFieldError(ctx, fc) {
 4849			ec.Errorf(ctx, "must not be null")
 4850		}
 4851		return graphql.Null
 4852	}
 4853	res := resTmp.(int)
 4854	fc.Result = res
 4855	return ec.marshalNInt2int(ctx, field.Selections, res)
 4856}
 4857
 4858func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4859	defer func() {
 4860		if r := recover(); r != nil {
 4861			ec.Error(ctx, ec.Recover(ctx, r))
 4862			ret = graphql.Null
 4863		}
 4864	}()
 4865	fc := &graphql.FieldContext{
 4866		Object:   "Comment",
 4867		Field:    field,
 4868		Args:     nil,
 4869		IsMethod: false,
 4870	}
 4871
 4872	ctx = graphql.WithFieldContext(ctx, fc)
 4873	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4874		ctx = rctx // use context from middleware stack in children
 4875		return obj.Author, nil
 4876	})
 4877	if err != nil {
 4878		ec.Error(ctx, err)
 4879		return graphql.Null
 4880	}
 4881	if resTmp == nil {
 4882		if !graphql.HasFieldError(ctx, fc) {
 4883			ec.Errorf(ctx, "must not be null")
 4884		}
 4885		return graphql.Null
 4886	}
 4887	res := resTmp.(identity.Interface)
 4888	fc.Result = res
 4889	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4890}
 4891
 4892func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4893	defer func() {
 4894		if r := recover(); r != nil {
 4895			ec.Error(ctx, ec.Recover(ctx, r))
 4896			ret = graphql.Null
 4897		}
 4898	}()
 4899	fc := &graphql.FieldContext{
 4900		Object:   "Comment",
 4901		Field:    field,
 4902		Args:     nil,
 4903		IsMethod: false,
 4904	}
 4905
 4906	ctx = graphql.WithFieldContext(ctx, fc)
 4907	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4908		ctx = rctx // use context from middleware stack in children
 4909		return obj.Message, nil
 4910	})
 4911	if err != nil {
 4912		ec.Error(ctx, err)
 4913		return graphql.Null
 4914	}
 4915	if resTmp == nil {
 4916		if !graphql.HasFieldError(ctx, fc) {
 4917			ec.Errorf(ctx, "must not be null")
 4918		}
 4919		return graphql.Null
 4920	}
 4921	res := resTmp.(string)
 4922	fc.Result = res
 4923	return ec.marshalNString2string(ctx, field.Selections, res)
 4924}
 4925
 4926func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4927	defer func() {
 4928		if r := recover(); r != nil {
 4929			ec.Error(ctx, ec.Recover(ctx, r))
 4930			ret = graphql.Null
 4931		}
 4932	}()
 4933	fc := &graphql.FieldContext{
 4934		Object:   "Comment",
 4935		Field:    field,
 4936		Args:     nil,
 4937		IsMethod: false,
 4938	}
 4939
 4940	ctx = graphql.WithFieldContext(ctx, fc)
 4941	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4942		ctx = rctx // use context from middleware stack in children
 4943		return obj.Files, nil
 4944	})
 4945	if err != nil {
 4946		ec.Error(ctx, err)
 4947		return graphql.Null
 4948	}
 4949	if resTmp == nil {
 4950		if !graphql.HasFieldError(ctx, fc) {
 4951			ec.Errorf(ctx, "must not be null")
 4952		}
 4953		return graphql.Null
 4954	}
 4955	res := resTmp.([]git.Hash)
 4956	fc.Result = res
 4957	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 4958}
 4959
 4960func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4961	defer func() {
 4962		if r := recover(); r != nil {
 4963			ec.Error(ctx, ec.Recover(ctx, r))
 4964			ret = graphql.Null
 4965		}
 4966	}()
 4967	fc := &graphql.FieldContext{
 4968		Object:   "CommentConnection",
 4969		Field:    field,
 4970		Args:     nil,
 4971		IsMethod: false,
 4972	}
 4973
 4974	ctx = graphql.WithFieldContext(ctx, fc)
 4975	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4976		ctx = rctx // use context from middleware stack in children
 4977		return obj.Edges, nil
 4978	})
 4979	if err != nil {
 4980		ec.Error(ctx, err)
 4981		return graphql.Null
 4982	}
 4983	if resTmp == nil {
 4984		if !graphql.HasFieldError(ctx, fc) {
 4985			ec.Errorf(ctx, "must not be null")
 4986		}
 4987		return graphql.Null
 4988	}
 4989	res := resTmp.([]*models.CommentEdge)
 4990	fc.Result = res
 4991	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4992}
 4993
 4994func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4995	defer func() {
 4996		if r := recover(); r != nil {
 4997			ec.Error(ctx, ec.Recover(ctx, r))
 4998			ret = graphql.Null
 4999		}
 5000	}()
 5001	fc := &graphql.FieldContext{
 5002		Object:   "CommentConnection",
 5003		Field:    field,
 5004		Args:     nil,
 5005		IsMethod: false,
 5006	}
 5007
 5008	ctx = graphql.WithFieldContext(ctx, fc)
 5009	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5010		ctx = rctx // use context from middleware stack in children
 5011		return obj.Nodes, nil
 5012	})
 5013	if err != nil {
 5014		ec.Error(ctx, err)
 5015		return graphql.Null
 5016	}
 5017	if resTmp == nil {
 5018		if !graphql.HasFieldError(ctx, fc) {
 5019			ec.Errorf(ctx, "must not be null")
 5020		}
 5021		return graphql.Null
 5022	}
 5023	res := resTmp.([]*bug.Comment)
 5024	fc.Result = res
 5025	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 5026}
 5027
 5028func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 5029	defer func() {
 5030		if r := recover(); r != nil {
 5031			ec.Error(ctx, ec.Recover(ctx, r))
 5032			ret = graphql.Null
 5033		}
 5034	}()
 5035	fc := &graphql.FieldContext{
 5036		Object:   "CommentConnection",
 5037		Field:    field,
 5038		Args:     nil,
 5039		IsMethod: false,
 5040	}
 5041
 5042	ctx = graphql.WithFieldContext(ctx, fc)
 5043	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5044		ctx = rctx // use context from middleware stack in children
 5045		return obj.PageInfo, nil
 5046	})
 5047	if err != nil {
 5048		ec.Error(ctx, err)
 5049		return graphql.Null
 5050	}
 5051	if resTmp == nil {
 5052		if !graphql.HasFieldError(ctx, fc) {
 5053			ec.Errorf(ctx, "must not be null")
 5054		}
 5055		return graphql.Null
 5056	}
 5057	res := resTmp.(*models.PageInfo)
 5058	fc.Result = res
 5059	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 5060}
 5061
 5062func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 5063	defer func() {
 5064		if r := recover(); r != nil {
 5065			ec.Error(ctx, ec.Recover(ctx, r))
 5066			ret = graphql.Null
 5067		}
 5068	}()
 5069	fc := &graphql.FieldContext{
 5070		Object:   "CommentConnection",
 5071		Field:    field,
 5072		Args:     nil,
 5073		IsMethod: false,
 5074	}
 5075
 5076	ctx = graphql.WithFieldContext(ctx, fc)
 5077	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5078		ctx = rctx // use context from middleware stack in children
 5079		return obj.TotalCount, nil
 5080	})
 5081	if err != nil {
 5082		ec.Error(ctx, err)
 5083		return graphql.Null
 5084	}
 5085	if resTmp == nil {
 5086		if !graphql.HasFieldError(ctx, fc) {
 5087			ec.Errorf(ctx, "must not be null")
 5088		}
 5089		return graphql.Null
 5090	}
 5091	res := resTmp.(int)
 5092	fc.Result = res
 5093	return ec.marshalNInt2int(ctx, field.Selections, res)
 5094}
 5095
 5096func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 5097	defer func() {
 5098		if r := recover(); r != nil {
 5099			ec.Error(ctx, ec.Recover(ctx, r))
 5100			ret = graphql.Null
 5101		}
 5102	}()
 5103	fc := &graphql.FieldContext{
 5104		Object:   "CommentEdge",
 5105		Field:    field,
 5106		Args:     nil,
 5107		IsMethod: false,
 5108	}
 5109
 5110	ctx = graphql.WithFieldContext(ctx, fc)
 5111	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5112		ctx = rctx // use context from middleware stack in children
 5113		return obj.Cursor, nil
 5114	})
 5115	if err != nil {
 5116		ec.Error(ctx, err)
 5117		return graphql.Null
 5118	}
 5119	if resTmp == nil {
 5120		if !graphql.HasFieldError(ctx, fc) {
 5121			ec.Errorf(ctx, "must not be null")
 5122		}
 5123		return graphql.Null
 5124	}
 5125	res := resTmp.(string)
 5126	fc.Result = res
 5127	return ec.marshalNString2string(ctx, field.Selections, res)
 5128}
 5129
 5130func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 5131	defer func() {
 5132		if r := recover(); r != nil {
 5133			ec.Error(ctx, ec.Recover(ctx, r))
 5134			ret = graphql.Null
 5135		}
 5136	}()
 5137	fc := &graphql.FieldContext{
 5138		Object:   "CommentEdge",
 5139		Field:    field,
 5140		Args:     nil,
 5141		IsMethod: false,
 5142	}
 5143
 5144	ctx = graphql.WithFieldContext(ctx, fc)
 5145	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5146		ctx = rctx // use context from middleware stack in children
 5147		return obj.Node, nil
 5148	})
 5149	if err != nil {
 5150		ec.Error(ctx, err)
 5151		return graphql.Null
 5152	}
 5153	if resTmp == nil {
 5154		if !graphql.HasFieldError(ctx, fc) {
 5155			ec.Errorf(ctx, "must not be null")
 5156		}
 5157		return graphql.Null
 5158	}
 5159	res := resTmp.(*bug.Comment)
 5160	fc.Result = res
 5161	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 5162}
 5163
 5164func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 5165	defer func() {
 5166		if r := recover(); r != nil {
 5167			ec.Error(ctx, ec.Recover(ctx, r))
 5168			ret = graphql.Null
 5169		}
 5170	}()
 5171	fc := &graphql.FieldContext{
 5172		Object:   "CommentHistoryStep",
 5173		Field:    field,
 5174		Args:     nil,
 5175		IsMethod: false,
 5176	}
 5177
 5178	ctx = graphql.WithFieldContext(ctx, fc)
 5179	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5180		ctx = rctx // use context from middleware stack in children
 5181		return obj.Message, nil
 5182	})
 5183	if err != nil {
 5184		ec.Error(ctx, err)
 5185		return graphql.Null
 5186	}
 5187	if resTmp == nil {
 5188		if !graphql.HasFieldError(ctx, fc) {
 5189			ec.Errorf(ctx, "must not be null")
 5190		}
 5191		return graphql.Null
 5192	}
 5193	res := resTmp.(string)
 5194	fc.Result = res
 5195	return ec.marshalNString2string(ctx, field.Selections, res)
 5196}
 5197
 5198func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 5199	defer func() {
 5200		if r := recover(); r != nil {
 5201			ec.Error(ctx, ec.Recover(ctx, r))
 5202			ret = graphql.Null
 5203		}
 5204	}()
 5205	fc := &graphql.FieldContext{
 5206		Object:   "CommentHistoryStep",
 5207		Field:    field,
 5208		Args:     nil,
 5209		IsMethod: true,
 5210	}
 5211
 5212	ctx = graphql.WithFieldContext(ctx, fc)
 5213	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5214		ctx = rctx // use context from middleware stack in children
 5215		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 5216	})
 5217	if err != nil {
 5218		ec.Error(ctx, err)
 5219		return graphql.Null
 5220	}
 5221	if resTmp == nil {
 5222		if !graphql.HasFieldError(ctx, fc) {
 5223			ec.Errorf(ctx, "must not be null")
 5224		}
 5225		return graphql.Null
 5226	}
 5227	res := resTmp.(*time.Time)
 5228	fc.Result = res
 5229	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5230}
 5231
 5232func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 5233	defer func() {
 5234		if r := recover(); r != nil {
 5235			ec.Error(ctx, ec.Recover(ctx, r))
 5236			ret = graphql.Null
 5237		}
 5238	}()
 5239	fc := &graphql.FieldContext{
 5240		Object:   "CommitAsNeededPayload",
 5241		Field:    field,
 5242		Args:     nil,
 5243		IsMethod: false,
 5244	}
 5245
 5246	ctx = graphql.WithFieldContext(ctx, fc)
 5247	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5248		ctx = rctx // use context from middleware stack in children
 5249		return obj.ClientMutationID, nil
 5250	})
 5251	if err != nil {
 5252		ec.Error(ctx, err)
 5253		return graphql.Null
 5254	}
 5255	if resTmp == nil {
 5256		return graphql.Null
 5257	}
 5258	res := resTmp.(*string)
 5259	fc.Result = res
 5260	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5261}
 5262
 5263func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 5264	defer func() {
 5265		if r := recover(); r != nil {
 5266			ec.Error(ctx, ec.Recover(ctx, r))
 5267			ret = graphql.Null
 5268		}
 5269	}()
 5270	fc := &graphql.FieldContext{
 5271		Object:   "CommitAsNeededPayload",
 5272		Field:    field,
 5273		Args:     nil,
 5274		IsMethod: false,
 5275	}
 5276
 5277	ctx = graphql.WithFieldContext(ctx, fc)
 5278	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5279		ctx = rctx // use context from middleware stack in children
 5280		return obj.Bug, nil
 5281	})
 5282	if err != nil {
 5283		ec.Error(ctx, err)
 5284		return graphql.Null
 5285	}
 5286	if resTmp == nil {
 5287		if !graphql.HasFieldError(ctx, fc) {
 5288			ec.Errorf(ctx, "must not be null")
 5289		}
 5290		return graphql.Null
 5291	}
 5292	res := resTmp.(*bug.Snapshot)
 5293	fc.Result = res
 5294	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 5295}
 5296
 5297func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5298	defer func() {
 5299		if r := recover(); r != nil {
 5300			ec.Error(ctx, ec.Recover(ctx, r))
 5301			ret = graphql.Null
 5302		}
 5303	}()
 5304	fc := &graphql.FieldContext{
 5305		Object:   "CommitPayload",
 5306		Field:    field,
 5307		Args:     nil,
 5308		IsMethod: false,
 5309	}
 5310
 5311	ctx = graphql.WithFieldContext(ctx, fc)
 5312	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5313		ctx = rctx // use context from middleware stack in children
 5314		return obj.ClientMutationID, nil
 5315	})
 5316	if err != nil {
 5317		ec.Error(ctx, err)
 5318		return graphql.Null
 5319	}
 5320	if resTmp == nil {
 5321		return graphql.Null
 5322	}
 5323	res := resTmp.(*string)
 5324	fc.Result = res
 5325	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5326}
 5327
 5328func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5329	defer func() {
 5330		if r := recover(); r != nil {
 5331			ec.Error(ctx, ec.Recover(ctx, r))
 5332			ret = graphql.Null
 5333		}
 5334	}()
 5335	fc := &graphql.FieldContext{
 5336		Object:   "CommitPayload",
 5337		Field:    field,
 5338		Args:     nil,
 5339		IsMethod: false,
 5340	}
 5341
 5342	ctx = graphql.WithFieldContext(ctx, fc)
 5343	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5344		ctx = rctx // use context from middleware stack in children
 5345		return obj.Bug, nil
 5346	})
 5347	if err != nil {
 5348		ec.Error(ctx, err)
 5349		return graphql.Null
 5350	}
 5351	if resTmp == nil {
 5352		if !graphql.HasFieldError(ctx, fc) {
 5353			ec.Errorf(ctx, "must not be null")
 5354		}
 5355		return graphql.Null
 5356	}
 5357	res := resTmp.(*bug.Snapshot)
 5358	fc.Result = res
 5359	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 5360}
 5361
 5362func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5363	defer func() {
 5364		if r := recover(); r != nil {
 5365			ec.Error(ctx, ec.Recover(ctx, r))
 5366			ret = graphql.Null
 5367		}
 5368	}()
 5369	fc := &graphql.FieldContext{
 5370		Object:   "CreateOperation",
 5371		Field:    field,
 5372		Args:     nil,
 5373		IsMethod: true,
 5374	}
 5375
 5376	ctx = graphql.WithFieldContext(ctx, fc)
 5377	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5378		ctx = rctx // use context from middleware stack in children
 5379		return ec.resolvers.CreateOperation().ID(rctx, obj)
 5380	})
 5381	if err != nil {
 5382		ec.Error(ctx, err)
 5383		return graphql.Null
 5384	}
 5385	if resTmp == nil {
 5386		if !graphql.HasFieldError(ctx, fc) {
 5387			ec.Errorf(ctx, "must not be null")
 5388		}
 5389		return graphql.Null
 5390	}
 5391	res := resTmp.(string)
 5392	fc.Result = res
 5393	return ec.marshalNString2string(ctx, field.Selections, res)
 5394}
 5395
 5396func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5397	defer func() {
 5398		if r := recover(); r != nil {
 5399			ec.Error(ctx, ec.Recover(ctx, r))
 5400			ret = graphql.Null
 5401		}
 5402	}()
 5403	fc := &graphql.FieldContext{
 5404		Object:   "CreateOperation",
 5405		Field:    field,
 5406		Args:     nil,
 5407		IsMethod: false,
 5408	}
 5409
 5410	ctx = graphql.WithFieldContext(ctx, fc)
 5411	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5412		ctx = rctx // use context from middleware stack in children
 5413		return obj.Author, nil
 5414	})
 5415	if err != nil {
 5416		ec.Error(ctx, err)
 5417		return graphql.Null
 5418	}
 5419	if resTmp == nil {
 5420		if !graphql.HasFieldError(ctx, fc) {
 5421			ec.Errorf(ctx, "must not be null")
 5422		}
 5423		return graphql.Null
 5424	}
 5425	res := resTmp.(identity.Interface)
 5426	fc.Result = res
 5427	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5428}
 5429
 5430func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5431	defer func() {
 5432		if r := recover(); r != nil {
 5433			ec.Error(ctx, ec.Recover(ctx, r))
 5434			ret = graphql.Null
 5435		}
 5436	}()
 5437	fc := &graphql.FieldContext{
 5438		Object:   "CreateOperation",
 5439		Field:    field,
 5440		Args:     nil,
 5441		IsMethod: true,
 5442	}
 5443
 5444	ctx = graphql.WithFieldContext(ctx, fc)
 5445	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5446		ctx = rctx // use context from middleware stack in children
 5447		return ec.resolvers.CreateOperation().Date(rctx, obj)
 5448	})
 5449	if err != nil {
 5450		ec.Error(ctx, err)
 5451		return graphql.Null
 5452	}
 5453	if resTmp == nil {
 5454		if !graphql.HasFieldError(ctx, fc) {
 5455			ec.Errorf(ctx, "must not be null")
 5456		}
 5457		return graphql.Null
 5458	}
 5459	res := resTmp.(*time.Time)
 5460	fc.Result = res
 5461	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5462}
 5463
 5464func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5465	defer func() {
 5466		if r := recover(); r != nil {
 5467			ec.Error(ctx, ec.Recover(ctx, r))
 5468			ret = graphql.Null
 5469		}
 5470	}()
 5471	fc := &graphql.FieldContext{
 5472		Object:   "CreateOperation",
 5473		Field:    field,
 5474		Args:     nil,
 5475		IsMethod: false,
 5476	}
 5477
 5478	ctx = graphql.WithFieldContext(ctx, fc)
 5479	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5480		ctx = rctx // use context from middleware stack in children
 5481		return obj.Title, nil
 5482	})
 5483	if err != nil {
 5484		ec.Error(ctx, err)
 5485		return graphql.Null
 5486	}
 5487	if resTmp == nil {
 5488		if !graphql.HasFieldError(ctx, fc) {
 5489			ec.Errorf(ctx, "must not be null")
 5490		}
 5491		return graphql.Null
 5492	}
 5493	res := resTmp.(string)
 5494	fc.Result = res
 5495	return ec.marshalNString2string(ctx, field.Selections, res)
 5496}
 5497
 5498func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5499	defer func() {
 5500		if r := recover(); r != nil {
 5501			ec.Error(ctx, ec.Recover(ctx, r))
 5502			ret = graphql.Null
 5503		}
 5504	}()
 5505	fc := &graphql.FieldContext{
 5506		Object:   "CreateOperation",
 5507		Field:    field,
 5508		Args:     nil,
 5509		IsMethod: false,
 5510	}
 5511
 5512	ctx = graphql.WithFieldContext(ctx, fc)
 5513	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5514		ctx = rctx // use context from middleware stack in children
 5515		return obj.Message, nil
 5516	})
 5517	if err != nil {
 5518		ec.Error(ctx, err)
 5519		return graphql.Null
 5520	}
 5521	if resTmp == nil {
 5522		if !graphql.HasFieldError(ctx, fc) {
 5523			ec.Errorf(ctx, "must not be null")
 5524		}
 5525		return graphql.Null
 5526	}
 5527	res := resTmp.(string)
 5528	fc.Result = res
 5529	return ec.marshalNString2string(ctx, field.Selections, res)
 5530}
 5531
 5532func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5533	defer func() {
 5534		if r := recover(); r != nil {
 5535			ec.Error(ctx, ec.Recover(ctx, r))
 5536			ret = graphql.Null
 5537		}
 5538	}()
 5539	fc := &graphql.FieldContext{
 5540		Object:   "CreateOperation",
 5541		Field:    field,
 5542		Args:     nil,
 5543		IsMethod: false,
 5544	}
 5545
 5546	ctx = graphql.WithFieldContext(ctx, fc)
 5547	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5548		ctx = rctx // use context from middleware stack in children
 5549		return obj.Files, nil
 5550	})
 5551	if err != nil {
 5552		ec.Error(ctx, err)
 5553		return graphql.Null
 5554	}
 5555	if resTmp == nil {
 5556		if !graphql.HasFieldError(ctx, fc) {
 5557			ec.Errorf(ctx, "must not be null")
 5558		}
 5559		return graphql.Null
 5560	}
 5561	res := resTmp.([]git.Hash)
 5562	fc.Result = res
 5563	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5564}
 5565
 5566func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5567	defer func() {
 5568		if r := recover(); r != nil {
 5569			ec.Error(ctx, ec.Recover(ctx, r))
 5570			ret = graphql.Null
 5571		}
 5572	}()
 5573	fc := &graphql.FieldContext{
 5574		Object:   "CreateTimelineItem",
 5575		Field:    field,
 5576		Args:     nil,
 5577		IsMethod: true,
 5578	}
 5579
 5580	ctx = graphql.WithFieldContext(ctx, fc)
 5581	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5582		ctx = rctx // use context from middleware stack in children
 5583		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5584	})
 5585	if err != nil {
 5586		ec.Error(ctx, err)
 5587		return graphql.Null
 5588	}
 5589	if resTmp == nil {
 5590		if !graphql.HasFieldError(ctx, fc) {
 5591			ec.Errorf(ctx, "must not be null")
 5592		}
 5593		return graphql.Null
 5594	}
 5595	res := resTmp.(string)
 5596	fc.Result = res
 5597	return ec.marshalNString2string(ctx, field.Selections, res)
 5598}
 5599
 5600func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5601	defer func() {
 5602		if r := recover(); r != nil {
 5603			ec.Error(ctx, ec.Recover(ctx, r))
 5604			ret = graphql.Null
 5605		}
 5606	}()
 5607	fc := &graphql.FieldContext{
 5608		Object:   "CreateTimelineItem",
 5609		Field:    field,
 5610		Args:     nil,
 5611		IsMethod: false,
 5612	}
 5613
 5614	ctx = graphql.WithFieldContext(ctx, fc)
 5615	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5616		ctx = rctx // use context from middleware stack in children
 5617		return obj.Author, nil
 5618	})
 5619	if err != nil {
 5620		ec.Error(ctx, err)
 5621		return graphql.Null
 5622	}
 5623	if resTmp == nil {
 5624		if !graphql.HasFieldError(ctx, fc) {
 5625			ec.Errorf(ctx, "must not be null")
 5626		}
 5627		return graphql.Null
 5628	}
 5629	res := resTmp.(identity.Interface)
 5630	fc.Result = res
 5631	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5632}
 5633
 5634func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5635	defer func() {
 5636		if r := recover(); r != nil {
 5637			ec.Error(ctx, ec.Recover(ctx, r))
 5638			ret = graphql.Null
 5639		}
 5640	}()
 5641	fc := &graphql.FieldContext{
 5642		Object:   "CreateTimelineItem",
 5643		Field:    field,
 5644		Args:     nil,
 5645		IsMethod: false,
 5646	}
 5647
 5648	ctx = graphql.WithFieldContext(ctx, fc)
 5649	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5650		ctx = rctx // use context from middleware stack in children
 5651		return obj.Message, nil
 5652	})
 5653	if err != nil {
 5654		ec.Error(ctx, err)
 5655		return graphql.Null
 5656	}
 5657	if resTmp == nil {
 5658		if !graphql.HasFieldError(ctx, fc) {
 5659			ec.Errorf(ctx, "must not be null")
 5660		}
 5661		return graphql.Null
 5662	}
 5663	res := resTmp.(string)
 5664	fc.Result = res
 5665	return ec.marshalNString2string(ctx, field.Selections, res)
 5666}
 5667
 5668func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5669	defer func() {
 5670		if r := recover(); r != nil {
 5671			ec.Error(ctx, ec.Recover(ctx, r))
 5672			ret = graphql.Null
 5673		}
 5674	}()
 5675	fc := &graphql.FieldContext{
 5676		Object:   "CreateTimelineItem",
 5677		Field:    field,
 5678		Args:     nil,
 5679		IsMethod: true,
 5680	}
 5681
 5682	ctx = graphql.WithFieldContext(ctx, fc)
 5683	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5684		ctx = rctx // use context from middleware stack in children
 5685		return obj.MessageIsEmpty(), nil
 5686	})
 5687	if err != nil {
 5688		ec.Error(ctx, err)
 5689		return graphql.Null
 5690	}
 5691	if resTmp == nil {
 5692		if !graphql.HasFieldError(ctx, fc) {
 5693			ec.Errorf(ctx, "must not be null")
 5694		}
 5695		return graphql.Null
 5696	}
 5697	res := resTmp.(bool)
 5698	fc.Result = res
 5699	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5700}
 5701
 5702func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5703	defer func() {
 5704		if r := recover(); r != nil {
 5705			ec.Error(ctx, ec.Recover(ctx, r))
 5706			ret = graphql.Null
 5707		}
 5708	}()
 5709	fc := &graphql.FieldContext{
 5710		Object:   "CreateTimelineItem",
 5711		Field:    field,
 5712		Args:     nil,
 5713		IsMethod: false,
 5714	}
 5715
 5716	ctx = graphql.WithFieldContext(ctx, fc)
 5717	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5718		ctx = rctx // use context from middleware stack in children
 5719		return obj.Files, nil
 5720	})
 5721	if err != nil {
 5722		ec.Error(ctx, err)
 5723		return graphql.Null
 5724	}
 5725	if resTmp == nil {
 5726		if !graphql.HasFieldError(ctx, fc) {
 5727			ec.Errorf(ctx, "must not be null")
 5728		}
 5729		return graphql.Null
 5730	}
 5731	res := resTmp.([]git.Hash)
 5732	fc.Result = res
 5733	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5734}
 5735
 5736func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5737	defer func() {
 5738		if r := recover(); r != nil {
 5739			ec.Error(ctx, ec.Recover(ctx, r))
 5740			ret = graphql.Null
 5741		}
 5742	}()
 5743	fc := &graphql.FieldContext{
 5744		Object:   "CreateTimelineItem",
 5745		Field:    field,
 5746		Args:     nil,
 5747		IsMethod: true,
 5748	}
 5749
 5750	ctx = graphql.WithFieldContext(ctx, fc)
 5751	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5752		ctx = rctx // use context from middleware stack in children
 5753		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5754	})
 5755	if err != nil {
 5756		ec.Error(ctx, err)
 5757		return graphql.Null
 5758	}
 5759	if resTmp == nil {
 5760		if !graphql.HasFieldError(ctx, fc) {
 5761			ec.Errorf(ctx, "must not be null")
 5762		}
 5763		return graphql.Null
 5764	}
 5765	res := resTmp.(*time.Time)
 5766	fc.Result = res
 5767	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5768}
 5769
 5770func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5771	defer func() {
 5772		if r := recover(); r != nil {
 5773			ec.Error(ctx, ec.Recover(ctx, r))
 5774			ret = graphql.Null
 5775		}
 5776	}()
 5777	fc := &graphql.FieldContext{
 5778		Object:   "CreateTimelineItem",
 5779		Field:    field,
 5780		Args:     nil,
 5781		IsMethod: true,
 5782	}
 5783
 5784	ctx = graphql.WithFieldContext(ctx, fc)
 5785	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5786		ctx = rctx // use context from middleware stack in children
 5787		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5788	})
 5789	if err != nil {
 5790		ec.Error(ctx, err)
 5791		return graphql.Null
 5792	}
 5793	if resTmp == nil {
 5794		if !graphql.HasFieldError(ctx, fc) {
 5795			ec.Errorf(ctx, "must not be null")
 5796		}
 5797		return graphql.Null
 5798	}
 5799	res := resTmp.(*time.Time)
 5800	fc.Result = res
 5801	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5802}
 5803
 5804func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5805	defer func() {
 5806		if r := recover(); r != nil {
 5807			ec.Error(ctx, ec.Recover(ctx, r))
 5808			ret = graphql.Null
 5809		}
 5810	}()
 5811	fc := &graphql.FieldContext{
 5812		Object:   "CreateTimelineItem",
 5813		Field:    field,
 5814		Args:     nil,
 5815		IsMethod: true,
 5816	}
 5817
 5818	ctx = graphql.WithFieldContext(ctx, fc)
 5819	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5820		ctx = rctx // use context from middleware stack in children
 5821		return obj.Edited(), nil
 5822	})
 5823	if err != nil {
 5824		ec.Error(ctx, err)
 5825		return graphql.Null
 5826	}
 5827	if resTmp == nil {
 5828		if !graphql.HasFieldError(ctx, fc) {
 5829			ec.Errorf(ctx, "must not be null")
 5830		}
 5831		return graphql.Null
 5832	}
 5833	res := resTmp.(bool)
 5834	fc.Result = res
 5835	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5836}
 5837
 5838func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5839	defer func() {
 5840		if r := recover(); r != nil {
 5841			ec.Error(ctx, ec.Recover(ctx, r))
 5842			ret = graphql.Null
 5843		}
 5844	}()
 5845	fc := &graphql.FieldContext{
 5846		Object:   "CreateTimelineItem",
 5847		Field:    field,
 5848		Args:     nil,
 5849		IsMethod: false,
 5850	}
 5851
 5852	ctx = graphql.WithFieldContext(ctx, fc)
 5853	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5854		ctx = rctx // use context from middleware stack in children
 5855		return obj.History, nil
 5856	})
 5857	if err != nil {
 5858		ec.Error(ctx, err)
 5859		return graphql.Null
 5860	}
 5861	if resTmp == nil {
 5862		if !graphql.HasFieldError(ctx, fc) {
 5863			ec.Errorf(ctx, "must not be null")
 5864		}
 5865		return graphql.Null
 5866	}
 5867	res := resTmp.([]bug.CommentHistoryStep)
 5868	fc.Result = res
 5869	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5870}
 5871
 5872func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5873	defer func() {
 5874		if r := recover(); r != nil {
 5875			ec.Error(ctx, ec.Recover(ctx, r))
 5876			ret = graphql.Null
 5877		}
 5878	}()
 5879	fc := &graphql.FieldContext{
 5880		Object:   "EditCommentOperation",
 5881		Field:    field,
 5882		Args:     nil,
 5883		IsMethod: true,
 5884	}
 5885
 5886	ctx = graphql.WithFieldContext(ctx, fc)
 5887	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5888		ctx = rctx // use context from middleware stack in children
 5889		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5890	})
 5891	if err != nil {
 5892		ec.Error(ctx, err)
 5893		return graphql.Null
 5894	}
 5895	if resTmp == nil {
 5896		if !graphql.HasFieldError(ctx, fc) {
 5897			ec.Errorf(ctx, "must not be null")
 5898		}
 5899		return graphql.Null
 5900	}
 5901	res := resTmp.(string)
 5902	fc.Result = res
 5903	return ec.marshalNString2string(ctx, field.Selections, res)
 5904}
 5905
 5906func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5907	defer func() {
 5908		if r := recover(); r != nil {
 5909			ec.Error(ctx, ec.Recover(ctx, r))
 5910			ret = graphql.Null
 5911		}
 5912	}()
 5913	fc := &graphql.FieldContext{
 5914		Object:   "EditCommentOperation",
 5915		Field:    field,
 5916		Args:     nil,
 5917		IsMethod: false,
 5918	}
 5919
 5920	ctx = graphql.WithFieldContext(ctx, fc)
 5921	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5922		ctx = rctx // use context from middleware stack in children
 5923		return obj.Author, nil
 5924	})
 5925	if err != nil {
 5926		ec.Error(ctx, err)
 5927		return graphql.Null
 5928	}
 5929	if resTmp == nil {
 5930		if !graphql.HasFieldError(ctx, fc) {
 5931			ec.Errorf(ctx, "must not be null")
 5932		}
 5933		return graphql.Null
 5934	}
 5935	res := resTmp.(identity.Interface)
 5936	fc.Result = res
 5937	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5938}
 5939
 5940func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5941	defer func() {
 5942		if r := recover(); r != nil {
 5943			ec.Error(ctx, ec.Recover(ctx, r))
 5944			ret = graphql.Null
 5945		}
 5946	}()
 5947	fc := &graphql.FieldContext{
 5948		Object:   "EditCommentOperation",
 5949		Field:    field,
 5950		Args:     nil,
 5951		IsMethod: true,
 5952	}
 5953
 5954	ctx = graphql.WithFieldContext(ctx, fc)
 5955	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5956		ctx = rctx // use context from middleware stack in children
 5957		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5958	})
 5959	if err != nil {
 5960		ec.Error(ctx, err)
 5961		return graphql.Null
 5962	}
 5963	if resTmp == nil {
 5964		if !graphql.HasFieldError(ctx, fc) {
 5965			ec.Errorf(ctx, "must not be null")
 5966		}
 5967		return graphql.Null
 5968	}
 5969	res := resTmp.(*time.Time)
 5970	fc.Result = res
 5971	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5972}
 5973
 5974func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5975	defer func() {
 5976		if r := recover(); r != nil {
 5977			ec.Error(ctx, ec.Recover(ctx, r))
 5978			ret = graphql.Null
 5979		}
 5980	}()
 5981	fc := &graphql.FieldContext{
 5982		Object:   "EditCommentOperation",
 5983		Field:    field,
 5984		Args:     nil,
 5985		IsMethod: true,
 5986	}
 5987
 5988	ctx = graphql.WithFieldContext(ctx, fc)
 5989	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5990		ctx = rctx // use context from middleware stack in children
 5991		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5992	})
 5993	if err != nil {
 5994		ec.Error(ctx, err)
 5995		return graphql.Null
 5996	}
 5997	if resTmp == nil {
 5998		if !graphql.HasFieldError(ctx, fc) {
 5999			ec.Errorf(ctx, "must not be null")
 6000		}
 6001		return graphql.Null
 6002	}
 6003	res := resTmp.(string)
 6004	fc.Result = res
 6005	return ec.marshalNString2string(ctx, field.Selections, res)
 6006}
 6007
 6008func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 6009	defer func() {
 6010		if r := recover(); r != nil {
 6011			ec.Error(ctx, ec.Recover(ctx, r))
 6012			ret = graphql.Null
 6013		}
 6014	}()
 6015	fc := &graphql.FieldContext{
 6016		Object:   "EditCommentOperation",
 6017		Field:    field,
 6018		Args:     nil,
 6019		IsMethod: false,
 6020	}
 6021
 6022	ctx = graphql.WithFieldContext(ctx, fc)
 6023	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6024		ctx = rctx // use context from middleware stack in children
 6025		return obj.Message, nil
 6026	})
 6027	if err != nil {
 6028		ec.Error(ctx, err)
 6029		return graphql.Null
 6030	}
 6031	if resTmp == nil {
 6032		if !graphql.HasFieldError(ctx, fc) {
 6033			ec.Errorf(ctx, "must not be null")
 6034		}
 6035		return graphql.Null
 6036	}
 6037	res := resTmp.(string)
 6038	fc.Result = res
 6039	return ec.marshalNString2string(ctx, field.Selections, res)
 6040}
 6041
 6042func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 6043	defer func() {
 6044		if r := recover(); r != nil {
 6045			ec.Error(ctx, ec.Recover(ctx, r))
 6046			ret = graphql.Null
 6047		}
 6048	}()
 6049	fc := &graphql.FieldContext{
 6050		Object:   "EditCommentOperation",
 6051		Field:    field,
 6052		Args:     nil,
 6053		IsMethod: false,
 6054	}
 6055
 6056	ctx = graphql.WithFieldContext(ctx, fc)
 6057	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6058		ctx = rctx // use context from middleware stack in children
 6059		return obj.Files, nil
 6060	})
 6061	if err != nil {
 6062		ec.Error(ctx, err)
 6063		return graphql.Null
 6064	}
 6065	if resTmp == nil {
 6066		if !graphql.HasFieldError(ctx, fc) {
 6067			ec.Errorf(ctx, "must not be null")
 6068		}
 6069		return graphql.Null
 6070	}
 6071	res := resTmp.([]git.Hash)
 6072	fc.Result = res
 6073	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 6074}
 6075
 6076func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6077	defer func() {
 6078		if r := recover(); r != nil {
 6079			ec.Error(ctx, ec.Recover(ctx, r))
 6080			ret = graphql.Null
 6081		}
 6082	}()
 6083	fc := &graphql.FieldContext{
 6084		Object:   "Identity",
 6085		Field:    field,
 6086		Args:     nil,
 6087		IsMethod: true,
 6088	}
 6089
 6090	ctx = graphql.WithFieldContext(ctx, fc)
 6091	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6092		ctx = rctx // use context from middleware stack in children
 6093		return ec.resolvers.Identity().ID(rctx, obj)
 6094	})
 6095	if err != nil {
 6096		ec.Error(ctx, err)
 6097		return graphql.Null
 6098	}
 6099	if resTmp == nil {
 6100		if !graphql.HasFieldError(ctx, fc) {
 6101			ec.Errorf(ctx, "must not be null")
 6102		}
 6103		return graphql.Null
 6104	}
 6105	res := resTmp.(string)
 6106	fc.Result = res
 6107	return ec.marshalNString2string(ctx, field.Selections, res)
 6108}
 6109
 6110func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6111	defer func() {
 6112		if r := recover(); r != nil {
 6113			ec.Error(ctx, ec.Recover(ctx, r))
 6114			ret = graphql.Null
 6115		}
 6116	}()
 6117	fc := &graphql.FieldContext{
 6118		Object:   "Identity",
 6119		Field:    field,
 6120		Args:     nil,
 6121		IsMethod: true,
 6122	}
 6123
 6124	ctx = graphql.WithFieldContext(ctx, fc)
 6125	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6126		ctx = rctx // use context from middleware stack in children
 6127		return ec.resolvers.Identity().HumanID(rctx, obj)
 6128	})
 6129	if err != nil {
 6130		ec.Error(ctx, err)
 6131		return graphql.Null
 6132	}
 6133	if resTmp == nil {
 6134		if !graphql.HasFieldError(ctx, fc) {
 6135			ec.Errorf(ctx, "must not be null")
 6136		}
 6137		return graphql.Null
 6138	}
 6139	res := resTmp.(string)
 6140	fc.Result = res
 6141	return ec.marshalNString2string(ctx, field.Selections, res)
 6142}
 6143
 6144func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6145	defer func() {
 6146		if r := recover(); r != nil {
 6147			ec.Error(ctx, ec.Recover(ctx, r))
 6148			ret = graphql.Null
 6149		}
 6150	}()
 6151	fc := &graphql.FieldContext{
 6152		Object:   "Identity",
 6153		Field:    field,
 6154		Args:     nil,
 6155		IsMethod: true,
 6156	}
 6157
 6158	ctx = graphql.WithFieldContext(ctx, fc)
 6159	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6160		ctx = rctx // use context from middleware stack in children
 6161		return obj.Name(), nil
 6162	})
 6163	if err != nil {
 6164		ec.Error(ctx, err)
 6165		return graphql.Null
 6166	}
 6167	if resTmp == nil {
 6168		return graphql.Null
 6169	}
 6170	res := resTmp.(string)
 6171	fc.Result = res
 6172	return ec.marshalOString2string(ctx, field.Selections, res)
 6173}
 6174
 6175func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6176	defer func() {
 6177		if r := recover(); r != nil {
 6178			ec.Error(ctx, ec.Recover(ctx, r))
 6179			ret = graphql.Null
 6180		}
 6181	}()
 6182	fc := &graphql.FieldContext{
 6183		Object:   "Identity",
 6184		Field:    field,
 6185		Args:     nil,
 6186		IsMethod: true,
 6187	}
 6188
 6189	ctx = graphql.WithFieldContext(ctx, fc)
 6190	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6191		ctx = rctx // use context from middleware stack in children
 6192		return obj.Email(), nil
 6193	})
 6194	if err != nil {
 6195		ec.Error(ctx, err)
 6196		return graphql.Null
 6197	}
 6198	if resTmp == nil {
 6199		return graphql.Null
 6200	}
 6201	res := resTmp.(string)
 6202	fc.Result = res
 6203	return ec.marshalOString2string(ctx, field.Selections, res)
 6204}
 6205
 6206func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6207	defer func() {
 6208		if r := recover(); r != nil {
 6209			ec.Error(ctx, ec.Recover(ctx, r))
 6210			ret = graphql.Null
 6211		}
 6212	}()
 6213	fc := &graphql.FieldContext{
 6214		Object:   "Identity",
 6215		Field:    field,
 6216		Args:     nil,
 6217		IsMethod: true,
 6218	}
 6219
 6220	ctx = graphql.WithFieldContext(ctx, fc)
 6221	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6222		ctx = rctx // use context from middleware stack in children
 6223		return obj.DisplayName(), nil
 6224	})
 6225	if err != nil {
 6226		ec.Error(ctx, err)
 6227		return graphql.Null
 6228	}
 6229	if resTmp == nil {
 6230		if !graphql.HasFieldError(ctx, fc) {
 6231			ec.Errorf(ctx, "must not be null")
 6232		}
 6233		return graphql.Null
 6234	}
 6235	res := resTmp.(string)
 6236	fc.Result = res
 6237	return ec.marshalNString2string(ctx, field.Selections, res)
 6238}
 6239
 6240func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6241	defer func() {
 6242		if r := recover(); r != nil {
 6243			ec.Error(ctx, ec.Recover(ctx, r))
 6244			ret = graphql.Null
 6245		}
 6246	}()
 6247	fc := &graphql.FieldContext{
 6248		Object:   "Identity",
 6249		Field:    field,
 6250		Args:     nil,
 6251		IsMethod: true,
 6252	}
 6253
 6254	ctx = graphql.WithFieldContext(ctx, fc)
 6255	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6256		ctx = rctx // use context from middleware stack in children
 6257		return obj.AvatarUrl(), nil
 6258	})
 6259	if err != nil {
 6260		ec.Error(ctx, err)
 6261		return graphql.Null
 6262	}
 6263	if resTmp == nil {
 6264		return graphql.Null
 6265	}
 6266	res := resTmp.(string)
 6267	fc.Result = res
 6268	return ec.marshalOString2string(ctx, field.Selections, res)
 6269}
 6270
 6271func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj identity.Interface) (ret graphql.Marshaler) {
 6272	defer func() {
 6273		if r := recover(); r != nil {
 6274			ec.Error(ctx, ec.Recover(ctx, r))
 6275			ret = graphql.Null
 6276		}
 6277	}()
 6278	fc := &graphql.FieldContext{
 6279		Object:   "Identity",
 6280		Field:    field,
 6281		Args:     nil,
 6282		IsMethod: true,
 6283	}
 6284
 6285	ctx = graphql.WithFieldContext(ctx, fc)
 6286	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6287		ctx = rctx // use context from middleware stack in children
 6288		return obj.IsProtected(), nil
 6289	})
 6290	if err != nil {
 6291		ec.Error(ctx, err)
 6292		return graphql.Null
 6293	}
 6294	if resTmp == nil {
 6295		if !graphql.HasFieldError(ctx, fc) {
 6296			ec.Errorf(ctx, "must not be null")
 6297		}
 6298		return graphql.Null
 6299	}
 6300	res := resTmp.(bool)
 6301	fc.Result = res
 6302	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6303}
 6304
 6305func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6306	defer func() {
 6307		if r := recover(); r != nil {
 6308			ec.Error(ctx, ec.Recover(ctx, r))
 6309			ret = graphql.Null
 6310		}
 6311	}()
 6312	fc := &graphql.FieldContext{
 6313		Object:   "IdentityConnection",
 6314		Field:    field,
 6315		Args:     nil,
 6316		IsMethod: false,
 6317	}
 6318
 6319	ctx = graphql.WithFieldContext(ctx, fc)
 6320	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6321		ctx = rctx // use context from middleware stack in children
 6322		return obj.Edges, nil
 6323	})
 6324	if err != nil {
 6325		ec.Error(ctx, err)
 6326		return graphql.Null
 6327	}
 6328	if resTmp == nil {
 6329		if !graphql.HasFieldError(ctx, fc) {
 6330			ec.Errorf(ctx, "must not be null")
 6331		}
 6332		return graphql.Null
 6333	}
 6334	res := resTmp.([]*models.IdentityEdge)
 6335	fc.Result = res
 6336	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 6337}
 6338
 6339func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6340	defer func() {
 6341		if r := recover(); r != nil {
 6342			ec.Error(ctx, ec.Recover(ctx, r))
 6343			ret = graphql.Null
 6344		}
 6345	}()
 6346	fc := &graphql.FieldContext{
 6347		Object:   "IdentityConnection",
 6348		Field:    field,
 6349		Args:     nil,
 6350		IsMethod: false,
 6351	}
 6352
 6353	ctx = graphql.WithFieldContext(ctx, fc)
 6354	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6355		ctx = rctx // use context from middleware stack in children
 6356		return obj.Nodes, nil
 6357	})
 6358	if err != nil {
 6359		ec.Error(ctx, err)
 6360		return graphql.Null
 6361	}
 6362	if resTmp == nil {
 6363		if !graphql.HasFieldError(ctx, fc) {
 6364			ec.Errorf(ctx, "must not be null")
 6365		}
 6366		return graphql.Null
 6367	}
 6368	res := resTmp.([]identity.Interface)
 6369	fc.Result = res
 6370	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterfaceᚄ(ctx, field.Selections, res)
 6371}
 6372
 6373func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6374	defer func() {
 6375		if r := recover(); r != nil {
 6376			ec.Error(ctx, ec.Recover(ctx, r))
 6377			ret = graphql.Null
 6378		}
 6379	}()
 6380	fc := &graphql.FieldContext{
 6381		Object:   "IdentityConnection",
 6382		Field:    field,
 6383		Args:     nil,
 6384		IsMethod: false,
 6385	}
 6386
 6387	ctx = graphql.WithFieldContext(ctx, fc)
 6388	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6389		ctx = rctx // use context from middleware stack in children
 6390		return obj.PageInfo, nil
 6391	})
 6392	if err != nil {
 6393		ec.Error(ctx, err)
 6394		return graphql.Null
 6395	}
 6396	if resTmp == nil {
 6397		if !graphql.HasFieldError(ctx, fc) {
 6398			ec.Errorf(ctx, "must not be null")
 6399		}
 6400		return graphql.Null
 6401	}
 6402	res := resTmp.(*models.PageInfo)
 6403	fc.Result = res
 6404	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6405}
 6406
 6407func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6408	defer func() {
 6409		if r := recover(); r != nil {
 6410			ec.Error(ctx, ec.Recover(ctx, r))
 6411			ret = graphql.Null
 6412		}
 6413	}()
 6414	fc := &graphql.FieldContext{
 6415		Object:   "IdentityConnection",
 6416		Field:    field,
 6417		Args:     nil,
 6418		IsMethod: false,
 6419	}
 6420
 6421	ctx = graphql.WithFieldContext(ctx, fc)
 6422	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6423		ctx = rctx // use context from middleware stack in children
 6424		return obj.TotalCount, nil
 6425	})
 6426	if err != nil {
 6427		ec.Error(ctx, err)
 6428		return graphql.Null
 6429	}
 6430	if resTmp == nil {
 6431		if !graphql.HasFieldError(ctx, fc) {
 6432			ec.Errorf(ctx, "must not be null")
 6433		}
 6434		return graphql.Null
 6435	}
 6436	res := resTmp.(int)
 6437	fc.Result = res
 6438	return ec.marshalNInt2int(ctx, field.Selections, res)
 6439}
 6440
 6441func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6442	defer func() {
 6443		if r := recover(); r != nil {
 6444			ec.Error(ctx, ec.Recover(ctx, r))
 6445			ret = graphql.Null
 6446		}
 6447	}()
 6448	fc := &graphql.FieldContext{
 6449		Object:   "IdentityEdge",
 6450		Field:    field,
 6451		Args:     nil,
 6452		IsMethod: false,
 6453	}
 6454
 6455	ctx = graphql.WithFieldContext(ctx, fc)
 6456	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6457		ctx = rctx // use context from middleware stack in children
 6458		return obj.Cursor, nil
 6459	})
 6460	if err != nil {
 6461		ec.Error(ctx, err)
 6462		return graphql.Null
 6463	}
 6464	if resTmp == nil {
 6465		if !graphql.HasFieldError(ctx, fc) {
 6466			ec.Errorf(ctx, "must not be null")
 6467		}
 6468		return graphql.Null
 6469	}
 6470	res := resTmp.(string)
 6471	fc.Result = res
 6472	return ec.marshalNString2string(ctx, field.Selections, res)
 6473}
 6474
 6475func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6476	defer func() {
 6477		if r := recover(); r != nil {
 6478			ec.Error(ctx, ec.Recover(ctx, r))
 6479			ret = graphql.Null
 6480		}
 6481	}()
 6482	fc := &graphql.FieldContext{
 6483		Object:   "IdentityEdge",
 6484		Field:    field,
 6485		Args:     nil,
 6486		IsMethod: false,
 6487	}
 6488
 6489	ctx = graphql.WithFieldContext(ctx, fc)
 6490	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6491		ctx = rctx // use context from middleware stack in children
 6492		return obj.Node, nil
 6493	})
 6494	if err != nil {
 6495		ec.Error(ctx, err)
 6496		return graphql.Null
 6497	}
 6498	if resTmp == nil {
 6499		if !graphql.HasFieldError(ctx, fc) {
 6500			ec.Errorf(ctx, "must not be null")
 6501		}
 6502		return graphql.Null
 6503	}
 6504	res := resTmp.(identity.Interface)
 6505	fc.Result = res
 6506	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6507}
 6508
 6509func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6510	defer func() {
 6511		if r := recover(); r != nil {
 6512			ec.Error(ctx, ec.Recover(ctx, r))
 6513			ret = graphql.Null
 6514		}
 6515	}()
 6516	fc := &graphql.FieldContext{
 6517		Object:   "Label",
 6518		Field:    field,
 6519		Args:     nil,
 6520		IsMethod: true,
 6521	}
 6522
 6523	ctx = graphql.WithFieldContext(ctx, fc)
 6524	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6525		ctx = rctx // use context from middleware stack in children
 6526		return ec.resolvers.Label().Name(rctx, obj)
 6527	})
 6528	if err != nil {
 6529		ec.Error(ctx, err)
 6530		return graphql.Null
 6531	}
 6532	if resTmp == nil {
 6533		if !graphql.HasFieldError(ctx, fc) {
 6534			ec.Errorf(ctx, "must not be null")
 6535		}
 6536		return graphql.Null
 6537	}
 6538	res := resTmp.(string)
 6539	fc.Result = res
 6540	return ec.marshalNString2string(ctx, field.Selections, res)
 6541}
 6542
 6543func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6544	defer func() {
 6545		if r := recover(); r != nil {
 6546			ec.Error(ctx, ec.Recover(ctx, r))
 6547			ret = graphql.Null
 6548		}
 6549	}()
 6550	fc := &graphql.FieldContext{
 6551		Object:   "Label",
 6552		Field:    field,
 6553		Args:     nil,
 6554		IsMethod: true,
 6555	}
 6556
 6557	ctx = graphql.WithFieldContext(ctx, fc)
 6558	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6559		ctx = rctx // use context from middleware stack in children
 6560		return ec.resolvers.Label().Color(rctx, obj)
 6561	})
 6562	if err != nil {
 6563		ec.Error(ctx, err)
 6564		return graphql.Null
 6565	}
 6566	if resTmp == nil {
 6567		if !graphql.HasFieldError(ctx, fc) {
 6568			ec.Errorf(ctx, "must not be null")
 6569		}
 6570		return graphql.Null
 6571	}
 6572	res := resTmp.(*color.RGBA)
 6573	fc.Result = res
 6574	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6575}
 6576
 6577func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6578	defer func() {
 6579		if r := recover(); r != nil {
 6580			ec.Error(ctx, ec.Recover(ctx, r))
 6581			ret = graphql.Null
 6582		}
 6583	}()
 6584	fc := &graphql.FieldContext{
 6585		Object:   "LabelChangeOperation",
 6586		Field:    field,
 6587		Args:     nil,
 6588		IsMethod: true,
 6589	}
 6590
 6591	ctx = graphql.WithFieldContext(ctx, fc)
 6592	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6593		ctx = rctx // use context from middleware stack in children
 6594		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6595	})
 6596	if err != nil {
 6597		ec.Error(ctx, err)
 6598		return graphql.Null
 6599	}
 6600	if resTmp == nil {
 6601		if !graphql.HasFieldError(ctx, fc) {
 6602			ec.Errorf(ctx, "must not be null")
 6603		}
 6604		return graphql.Null
 6605	}
 6606	res := resTmp.(string)
 6607	fc.Result = res
 6608	return ec.marshalNString2string(ctx, field.Selections, res)
 6609}
 6610
 6611func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6612	defer func() {
 6613		if r := recover(); r != nil {
 6614			ec.Error(ctx, ec.Recover(ctx, r))
 6615			ret = graphql.Null
 6616		}
 6617	}()
 6618	fc := &graphql.FieldContext{
 6619		Object:   "LabelChangeOperation",
 6620		Field:    field,
 6621		Args:     nil,
 6622		IsMethod: false,
 6623	}
 6624
 6625	ctx = graphql.WithFieldContext(ctx, fc)
 6626	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6627		ctx = rctx // use context from middleware stack in children
 6628		return obj.Author, nil
 6629	})
 6630	if err != nil {
 6631		ec.Error(ctx, err)
 6632		return graphql.Null
 6633	}
 6634	if resTmp == nil {
 6635		if !graphql.HasFieldError(ctx, fc) {
 6636			ec.Errorf(ctx, "must not be null")
 6637		}
 6638		return graphql.Null
 6639	}
 6640	res := resTmp.(identity.Interface)
 6641	fc.Result = res
 6642	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6643}
 6644
 6645func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6646	defer func() {
 6647		if r := recover(); r != nil {
 6648			ec.Error(ctx, ec.Recover(ctx, r))
 6649			ret = graphql.Null
 6650		}
 6651	}()
 6652	fc := &graphql.FieldContext{
 6653		Object:   "LabelChangeOperation",
 6654		Field:    field,
 6655		Args:     nil,
 6656		IsMethod: true,
 6657	}
 6658
 6659	ctx = graphql.WithFieldContext(ctx, fc)
 6660	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6661		ctx = rctx // use context from middleware stack in children
 6662		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6663	})
 6664	if err != nil {
 6665		ec.Error(ctx, err)
 6666		return graphql.Null
 6667	}
 6668	if resTmp == nil {
 6669		if !graphql.HasFieldError(ctx, fc) {
 6670			ec.Errorf(ctx, "must not be null")
 6671		}
 6672		return graphql.Null
 6673	}
 6674	res := resTmp.(*time.Time)
 6675	fc.Result = res
 6676	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6677}
 6678
 6679func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6680	defer func() {
 6681		if r := recover(); r != nil {
 6682			ec.Error(ctx, ec.Recover(ctx, r))
 6683			ret = graphql.Null
 6684		}
 6685	}()
 6686	fc := &graphql.FieldContext{
 6687		Object:   "LabelChangeOperation",
 6688		Field:    field,
 6689		Args:     nil,
 6690		IsMethod: false,
 6691	}
 6692
 6693	ctx = graphql.WithFieldContext(ctx, fc)
 6694	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6695		ctx = rctx // use context from middleware stack in children
 6696		return obj.Added, nil
 6697	})
 6698	if err != nil {
 6699		ec.Error(ctx, err)
 6700		return graphql.Null
 6701	}
 6702	if resTmp == nil {
 6703		if !graphql.HasFieldError(ctx, fc) {
 6704			ec.Errorf(ctx, "must not be null")
 6705		}
 6706		return graphql.Null
 6707	}
 6708	res := resTmp.([]bug.Label)
 6709	fc.Result = res
 6710	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6711}
 6712
 6713func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6714	defer func() {
 6715		if r := recover(); r != nil {
 6716			ec.Error(ctx, ec.Recover(ctx, r))
 6717			ret = graphql.Null
 6718		}
 6719	}()
 6720	fc := &graphql.FieldContext{
 6721		Object:   "LabelChangeOperation",
 6722		Field:    field,
 6723		Args:     nil,
 6724		IsMethod: false,
 6725	}
 6726
 6727	ctx = graphql.WithFieldContext(ctx, fc)
 6728	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6729		ctx = rctx // use context from middleware stack in children
 6730		return obj.Removed, nil
 6731	})
 6732	if err != nil {
 6733		ec.Error(ctx, err)
 6734		return graphql.Null
 6735	}
 6736	if resTmp == nil {
 6737		if !graphql.HasFieldError(ctx, fc) {
 6738			ec.Errorf(ctx, "must not be null")
 6739		}
 6740		return graphql.Null
 6741	}
 6742	res := resTmp.([]bug.Label)
 6743	fc.Result = res
 6744	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6745}
 6746
 6747func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6748	defer func() {
 6749		if r := recover(); r != nil {
 6750			ec.Error(ctx, ec.Recover(ctx, r))
 6751			ret = graphql.Null
 6752		}
 6753	}()
 6754	fc := &graphql.FieldContext{
 6755		Object:   "LabelChangeResult",
 6756		Field:    field,
 6757		Args:     nil,
 6758		IsMethod: false,
 6759	}
 6760
 6761	ctx = graphql.WithFieldContext(ctx, fc)
 6762	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6763		ctx = rctx // use context from middleware stack in children
 6764		return obj.Label, nil
 6765	})
 6766	if err != nil {
 6767		ec.Error(ctx, err)
 6768		return graphql.Null
 6769	}
 6770	if resTmp == nil {
 6771		if !graphql.HasFieldError(ctx, fc) {
 6772			ec.Errorf(ctx, "must not be null")
 6773		}
 6774		return graphql.Null
 6775	}
 6776	res := resTmp.(bug.Label)
 6777	fc.Result = res
 6778	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6779}
 6780
 6781func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6782	defer func() {
 6783		if r := recover(); r != nil {
 6784			ec.Error(ctx, ec.Recover(ctx, r))
 6785			ret = graphql.Null
 6786		}
 6787	}()
 6788	fc := &graphql.FieldContext{
 6789		Object:   "LabelChangeResult",
 6790		Field:    field,
 6791		Args:     nil,
 6792		IsMethod: true,
 6793	}
 6794
 6795	ctx = graphql.WithFieldContext(ctx, fc)
 6796	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6797		ctx = rctx // use context from middleware stack in children
 6798		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6799	})
 6800	if err != nil {
 6801		ec.Error(ctx, err)
 6802		return graphql.Null
 6803	}
 6804	if resTmp == nil {
 6805		if !graphql.HasFieldError(ctx, fc) {
 6806			ec.Errorf(ctx, "must not be null")
 6807		}
 6808		return graphql.Null
 6809	}
 6810	res := resTmp.(models.LabelChangeStatus)
 6811	fc.Result = res
 6812	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6813}
 6814
 6815func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6816	defer func() {
 6817		if r := recover(); r != nil {
 6818			ec.Error(ctx, ec.Recover(ctx, r))
 6819			ret = graphql.Null
 6820		}
 6821	}()
 6822	fc := &graphql.FieldContext{
 6823		Object:   "LabelChangeTimelineItem",
 6824		Field:    field,
 6825		Args:     nil,
 6826		IsMethod: true,
 6827	}
 6828
 6829	ctx = graphql.WithFieldContext(ctx, fc)
 6830	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6831		ctx = rctx // use context from middleware stack in children
 6832		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6833	})
 6834	if err != nil {
 6835		ec.Error(ctx, err)
 6836		return graphql.Null
 6837	}
 6838	if resTmp == nil {
 6839		if !graphql.HasFieldError(ctx, fc) {
 6840			ec.Errorf(ctx, "must not be null")
 6841		}
 6842		return graphql.Null
 6843	}
 6844	res := resTmp.(string)
 6845	fc.Result = res
 6846	return ec.marshalNString2string(ctx, field.Selections, res)
 6847}
 6848
 6849func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6850	defer func() {
 6851		if r := recover(); r != nil {
 6852			ec.Error(ctx, ec.Recover(ctx, r))
 6853			ret = graphql.Null
 6854		}
 6855	}()
 6856	fc := &graphql.FieldContext{
 6857		Object:   "LabelChangeTimelineItem",
 6858		Field:    field,
 6859		Args:     nil,
 6860		IsMethod: false,
 6861	}
 6862
 6863	ctx = graphql.WithFieldContext(ctx, fc)
 6864	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6865		ctx = rctx // use context from middleware stack in children
 6866		return obj.Author, nil
 6867	})
 6868	if err != nil {
 6869		ec.Error(ctx, err)
 6870		return graphql.Null
 6871	}
 6872	if resTmp == nil {
 6873		if !graphql.HasFieldError(ctx, fc) {
 6874			ec.Errorf(ctx, "must not be null")
 6875		}
 6876		return graphql.Null
 6877	}
 6878	res := resTmp.(identity.Interface)
 6879	fc.Result = res
 6880	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6881}
 6882
 6883func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6884	defer func() {
 6885		if r := recover(); r != nil {
 6886			ec.Error(ctx, ec.Recover(ctx, r))
 6887			ret = graphql.Null
 6888		}
 6889	}()
 6890	fc := &graphql.FieldContext{
 6891		Object:   "LabelChangeTimelineItem",
 6892		Field:    field,
 6893		Args:     nil,
 6894		IsMethod: true,
 6895	}
 6896
 6897	ctx = graphql.WithFieldContext(ctx, fc)
 6898	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6899		ctx = rctx // use context from middleware stack in children
 6900		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6901	})
 6902	if err != nil {
 6903		ec.Error(ctx, err)
 6904		return graphql.Null
 6905	}
 6906	if resTmp == nil {
 6907		if !graphql.HasFieldError(ctx, fc) {
 6908			ec.Errorf(ctx, "must not be null")
 6909		}
 6910		return graphql.Null
 6911	}
 6912	res := resTmp.(*time.Time)
 6913	fc.Result = res
 6914	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6915}
 6916
 6917func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6918	defer func() {
 6919		if r := recover(); r != nil {
 6920			ec.Error(ctx, ec.Recover(ctx, r))
 6921			ret = graphql.Null
 6922		}
 6923	}()
 6924	fc := &graphql.FieldContext{
 6925		Object:   "LabelChangeTimelineItem",
 6926		Field:    field,
 6927		Args:     nil,
 6928		IsMethod: false,
 6929	}
 6930
 6931	ctx = graphql.WithFieldContext(ctx, fc)
 6932	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6933		ctx = rctx // use context from middleware stack in children
 6934		return obj.Added, nil
 6935	})
 6936	if err != nil {
 6937		ec.Error(ctx, err)
 6938		return graphql.Null
 6939	}
 6940	if resTmp == nil {
 6941		if !graphql.HasFieldError(ctx, fc) {
 6942			ec.Errorf(ctx, "must not be null")
 6943		}
 6944		return graphql.Null
 6945	}
 6946	res := resTmp.([]bug.Label)
 6947	fc.Result = res
 6948	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6949}
 6950
 6951func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6952	defer func() {
 6953		if r := recover(); r != nil {
 6954			ec.Error(ctx, ec.Recover(ctx, r))
 6955			ret = graphql.Null
 6956		}
 6957	}()
 6958	fc := &graphql.FieldContext{
 6959		Object:   "LabelChangeTimelineItem",
 6960		Field:    field,
 6961		Args:     nil,
 6962		IsMethod: false,
 6963	}
 6964
 6965	ctx = graphql.WithFieldContext(ctx, fc)
 6966	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6967		ctx = rctx // use context from middleware stack in children
 6968		return obj.Removed, nil
 6969	})
 6970	if err != nil {
 6971		ec.Error(ctx, err)
 6972		return graphql.Null
 6973	}
 6974	if resTmp == nil {
 6975		if !graphql.HasFieldError(ctx, fc) {
 6976			ec.Errorf(ctx, "must not be null")
 6977		}
 6978		return graphql.Null
 6979	}
 6980	res := resTmp.([]bug.Label)
 6981	fc.Result = res
 6982	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6983}
 6984
 6985func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6986	defer func() {
 6987		if r := recover(); r != nil {
 6988			ec.Error(ctx, ec.Recover(ctx, r))
 6989			ret = graphql.Null
 6990		}
 6991	}()
 6992	fc := &graphql.FieldContext{
 6993		Object:   "LabelConnection",
 6994		Field:    field,
 6995		Args:     nil,
 6996		IsMethod: false,
 6997	}
 6998
 6999	ctx = graphql.WithFieldContext(ctx, fc)
 7000	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7001		ctx = rctx // use context from middleware stack in children
 7002		return obj.Edges, nil
 7003	})
 7004	if err != nil {
 7005		ec.Error(ctx, err)
 7006		return graphql.Null
 7007	}
 7008	if resTmp == nil {
 7009		if !graphql.HasFieldError(ctx, fc) {
 7010			ec.Errorf(ctx, "must not be null")
 7011		}
 7012		return graphql.Null
 7013	}
 7014	res := resTmp.([]*models.LabelEdge)
 7015	fc.Result = res
 7016	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 7017}
 7018
 7019func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 7020	defer func() {
 7021		if r := recover(); r != nil {
 7022			ec.Error(ctx, ec.Recover(ctx, r))
 7023			ret = graphql.Null
 7024		}
 7025	}()
 7026	fc := &graphql.FieldContext{
 7027		Object:   "LabelConnection",
 7028		Field:    field,
 7029		Args:     nil,
 7030		IsMethod: false,
 7031	}
 7032
 7033	ctx = graphql.WithFieldContext(ctx, fc)
 7034	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7035		ctx = rctx // use context from middleware stack in children
 7036		return obj.Nodes, nil
 7037	})
 7038	if err != nil {
 7039		ec.Error(ctx, err)
 7040		return graphql.Null
 7041	}
 7042	if resTmp == nil {
 7043		if !graphql.HasFieldError(ctx, fc) {
 7044			ec.Errorf(ctx, "must not be null")
 7045		}
 7046		return graphql.Null
 7047	}
 7048	res := resTmp.([]bug.Label)
 7049	fc.Result = res
 7050	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 7051}
 7052
 7053func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 7054	defer func() {
 7055		if r := recover(); r != nil {
 7056			ec.Error(ctx, ec.Recover(ctx, r))
 7057			ret = graphql.Null
 7058		}
 7059	}()
 7060	fc := &graphql.FieldContext{
 7061		Object:   "LabelConnection",
 7062		Field:    field,
 7063		Args:     nil,
 7064		IsMethod: false,
 7065	}
 7066
 7067	ctx = graphql.WithFieldContext(ctx, fc)
 7068	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7069		ctx = rctx // use context from middleware stack in children
 7070		return obj.PageInfo, nil
 7071	})
 7072	if err != nil {
 7073		ec.Error(ctx, err)
 7074		return graphql.Null
 7075	}
 7076	if resTmp == nil {
 7077		if !graphql.HasFieldError(ctx, fc) {
 7078			ec.Errorf(ctx, "must not be null")
 7079		}
 7080		return graphql.Null
 7081	}
 7082	res := resTmp.(*models.PageInfo)
 7083	fc.Result = res
 7084	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7085}
 7086
 7087func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 7088	defer func() {
 7089		if r := recover(); r != nil {
 7090			ec.Error(ctx, ec.Recover(ctx, r))
 7091			ret = graphql.Null
 7092		}
 7093	}()
 7094	fc := &graphql.FieldContext{
 7095		Object:   "LabelConnection",
 7096		Field:    field,
 7097		Args:     nil,
 7098		IsMethod: false,
 7099	}
 7100
 7101	ctx = graphql.WithFieldContext(ctx, fc)
 7102	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7103		ctx = rctx // use context from middleware stack in children
 7104		return obj.TotalCount, nil
 7105	})
 7106	if err != nil {
 7107		ec.Error(ctx, err)
 7108		return graphql.Null
 7109	}
 7110	if resTmp == nil {
 7111		if !graphql.HasFieldError(ctx, fc) {
 7112			ec.Errorf(ctx, "must not be null")
 7113		}
 7114		return graphql.Null
 7115	}
 7116	res := resTmp.(int)
 7117	fc.Result = res
 7118	return ec.marshalNInt2int(ctx, field.Selections, res)
 7119}
 7120
 7121func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 7122	defer func() {
 7123		if r := recover(); r != nil {
 7124			ec.Error(ctx, ec.Recover(ctx, r))
 7125			ret = graphql.Null
 7126		}
 7127	}()
 7128	fc := &graphql.FieldContext{
 7129		Object:   "LabelEdge",
 7130		Field:    field,
 7131		Args:     nil,
 7132		IsMethod: false,
 7133	}
 7134
 7135	ctx = graphql.WithFieldContext(ctx, fc)
 7136	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7137		ctx = rctx // use context from middleware stack in children
 7138		return obj.Cursor, nil
 7139	})
 7140	if err != nil {
 7141		ec.Error(ctx, err)
 7142		return graphql.Null
 7143	}
 7144	if resTmp == nil {
 7145		if !graphql.HasFieldError(ctx, fc) {
 7146			ec.Errorf(ctx, "must not be null")
 7147		}
 7148		return graphql.Null
 7149	}
 7150	res := resTmp.(string)
 7151	fc.Result = res
 7152	return ec.marshalNString2string(ctx, field.Selections, res)
 7153}
 7154
 7155func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 7156	defer func() {
 7157		if r := recover(); r != nil {
 7158			ec.Error(ctx, ec.Recover(ctx, r))
 7159			ret = graphql.Null
 7160		}
 7161	}()
 7162	fc := &graphql.FieldContext{
 7163		Object:   "LabelEdge",
 7164		Field:    field,
 7165		Args:     nil,
 7166		IsMethod: false,
 7167	}
 7168
 7169	ctx = graphql.WithFieldContext(ctx, fc)
 7170	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7171		ctx = rctx // use context from middleware stack in children
 7172		return obj.Node, nil
 7173	})
 7174	if err != nil {
 7175		ec.Error(ctx, err)
 7176		return graphql.Null
 7177	}
 7178	if resTmp == nil {
 7179		if !graphql.HasFieldError(ctx, fc) {
 7180			ec.Errorf(ctx, "must not be null")
 7181		}
 7182		return graphql.Null
 7183	}
 7184	res := resTmp.(bug.Label)
 7185	fc.Result = res
 7186	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 7187}
 7188
 7189func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7190	defer func() {
 7191		if r := recover(); r != nil {
 7192			ec.Error(ctx, ec.Recover(ctx, r))
 7193			ret = graphql.Null
 7194		}
 7195	}()
 7196	fc := &graphql.FieldContext{
 7197		Object:   "Mutation",
 7198		Field:    field,
 7199		Args:     nil,
 7200		IsMethod: true,
 7201	}
 7202
 7203	ctx = graphql.WithFieldContext(ctx, fc)
 7204	rawArgs := field.ArgumentMap(ec.Variables)
 7205	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 7206	if err != nil {
 7207		ec.Error(ctx, err)
 7208		return graphql.Null
 7209	}
 7210	fc.Args = args
 7211	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7212		ctx = rctx // use context from middleware stack in children
 7213		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 7214	})
 7215	if err != nil {
 7216		ec.Error(ctx, err)
 7217		return graphql.Null
 7218	}
 7219	if resTmp == nil {
 7220		if !graphql.HasFieldError(ctx, fc) {
 7221			ec.Errorf(ctx, "must not be null")
 7222		}
 7223		return graphql.Null
 7224	}
 7225	res := resTmp.(*models.NewBugPayload)
 7226	fc.Result = res
 7227	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 7228}
 7229
 7230func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7231	defer func() {
 7232		if r := recover(); r != nil {
 7233			ec.Error(ctx, ec.Recover(ctx, r))
 7234			ret = graphql.Null
 7235		}
 7236	}()
 7237	fc := &graphql.FieldContext{
 7238		Object:   "Mutation",
 7239		Field:    field,
 7240		Args:     nil,
 7241		IsMethod: true,
 7242	}
 7243
 7244	ctx = graphql.WithFieldContext(ctx, fc)
 7245	rawArgs := field.ArgumentMap(ec.Variables)
 7246	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 7247	if err != nil {
 7248		ec.Error(ctx, err)
 7249		return graphql.Null
 7250	}
 7251	fc.Args = args
 7252	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7253		ctx = rctx // use context from middleware stack in children
 7254		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 7255	})
 7256	if err != nil {
 7257		ec.Error(ctx, err)
 7258		return graphql.Null
 7259	}
 7260	if resTmp == nil {
 7261		if !graphql.HasFieldError(ctx, fc) {
 7262			ec.Errorf(ctx, "must not be null")
 7263		}
 7264		return graphql.Null
 7265	}
 7266	res := resTmp.(*models.AddCommentPayload)
 7267	fc.Result = res
 7268	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 7269}
 7270
 7271func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7272	defer func() {
 7273		if r := recover(); r != nil {
 7274			ec.Error(ctx, ec.Recover(ctx, r))
 7275			ret = graphql.Null
 7276		}
 7277	}()
 7278	fc := &graphql.FieldContext{
 7279		Object:   "Mutation",
 7280		Field:    field,
 7281		Args:     nil,
 7282		IsMethod: true,
 7283	}
 7284
 7285	ctx = graphql.WithFieldContext(ctx, fc)
 7286	rawArgs := field.ArgumentMap(ec.Variables)
 7287	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 7288	if err != nil {
 7289		ec.Error(ctx, err)
 7290		return graphql.Null
 7291	}
 7292	fc.Args = args
 7293	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7294		ctx = rctx // use context from middleware stack in children
 7295		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 7296	})
 7297	if err != nil {
 7298		ec.Error(ctx, err)
 7299		return graphql.Null
 7300	}
 7301	if resTmp == nil {
 7302		if !graphql.HasFieldError(ctx, fc) {
 7303			ec.Errorf(ctx, "must not be null")
 7304		}
 7305		return graphql.Null
 7306	}
 7307	res := resTmp.(*models.ChangeLabelPayload)
 7308	fc.Result = res
 7309	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 7310}
 7311
 7312func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7313	defer func() {
 7314		if r := recover(); r != nil {
 7315			ec.Error(ctx, ec.Recover(ctx, r))
 7316			ret = graphql.Null
 7317		}
 7318	}()
 7319	fc := &graphql.FieldContext{
 7320		Object:   "Mutation",
 7321		Field:    field,
 7322		Args:     nil,
 7323		IsMethod: true,
 7324	}
 7325
 7326	ctx = graphql.WithFieldContext(ctx, fc)
 7327	rawArgs := field.ArgumentMap(ec.Variables)
 7328	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 7329	if err != nil {
 7330		ec.Error(ctx, err)
 7331		return graphql.Null
 7332	}
 7333	fc.Args = args
 7334	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7335		ctx = rctx // use context from middleware stack in children
 7336		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 7337	})
 7338	if err != nil {
 7339		ec.Error(ctx, err)
 7340		return graphql.Null
 7341	}
 7342	if resTmp == nil {
 7343		if !graphql.HasFieldError(ctx, fc) {
 7344			ec.Errorf(ctx, "must not be null")
 7345		}
 7346		return graphql.Null
 7347	}
 7348	res := resTmp.(*models.OpenBugPayload)
 7349	fc.Result = res
 7350	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 7351}
 7352
 7353func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7354	defer func() {
 7355		if r := recover(); r != nil {
 7356			ec.Error(ctx, ec.Recover(ctx, r))
 7357			ret = graphql.Null
 7358		}
 7359	}()
 7360	fc := &graphql.FieldContext{
 7361		Object:   "Mutation",
 7362		Field:    field,
 7363		Args:     nil,
 7364		IsMethod: true,
 7365	}
 7366
 7367	ctx = graphql.WithFieldContext(ctx, fc)
 7368	rawArgs := field.ArgumentMap(ec.Variables)
 7369	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 7370	if err != nil {
 7371		ec.Error(ctx, err)
 7372		return graphql.Null
 7373	}
 7374	fc.Args = args
 7375	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7376		ctx = rctx // use context from middleware stack in children
 7377		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 7378	})
 7379	if err != nil {
 7380		ec.Error(ctx, err)
 7381		return graphql.Null
 7382	}
 7383	if resTmp == nil {
 7384		if !graphql.HasFieldError(ctx, fc) {
 7385			ec.Errorf(ctx, "must not be null")
 7386		}
 7387		return graphql.Null
 7388	}
 7389	res := resTmp.(*models.CloseBugPayload)
 7390	fc.Result = res
 7391	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 7392}
 7393
 7394func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7395	defer func() {
 7396		if r := recover(); r != nil {
 7397			ec.Error(ctx, ec.Recover(ctx, r))
 7398			ret = graphql.Null
 7399		}
 7400	}()
 7401	fc := &graphql.FieldContext{
 7402		Object:   "Mutation",
 7403		Field:    field,
 7404		Args:     nil,
 7405		IsMethod: true,
 7406	}
 7407
 7408	ctx = graphql.WithFieldContext(ctx, fc)
 7409	rawArgs := field.ArgumentMap(ec.Variables)
 7410	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 7411	if err != nil {
 7412		ec.Error(ctx, err)
 7413		return graphql.Null
 7414	}
 7415	fc.Args = args
 7416	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7417		ctx = rctx // use context from middleware stack in children
 7418		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 7419	})
 7420	if err != nil {
 7421		ec.Error(ctx, err)
 7422		return graphql.Null
 7423	}
 7424	if resTmp == nil {
 7425		if !graphql.HasFieldError(ctx, fc) {
 7426			ec.Errorf(ctx, "must not be null")
 7427		}
 7428		return graphql.Null
 7429	}
 7430	res := resTmp.(*models.SetTitlePayload)
 7431	fc.Result = res
 7432	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 7433}
 7434
 7435func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7436	defer func() {
 7437		if r := recover(); r != nil {
 7438			ec.Error(ctx, ec.Recover(ctx, r))
 7439			ret = graphql.Null
 7440		}
 7441	}()
 7442	fc := &graphql.FieldContext{
 7443		Object:   "Mutation",
 7444		Field:    field,
 7445		Args:     nil,
 7446		IsMethod: true,
 7447	}
 7448
 7449	ctx = graphql.WithFieldContext(ctx, fc)
 7450	rawArgs := field.ArgumentMap(ec.Variables)
 7451	args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
 7452	if err != nil {
 7453		ec.Error(ctx, err)
 7454		return graphql.Null
 7455	}
 7456	fc.Args = args
 7457	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7458		ctx = rctx // use context from middleware stack in children
 7459		return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
 7460	})
 7461	if err != nil {
 7462		ec.Error(ctx, err)
 7463		return graphql.Null
 7464	}
 7465	if resTmp == nil {
 7466		if !graphql.HasFieldError(ctx, fc) {
 7467			ec.Errorf(ctx, "must not be null")
 7468		}
 7469		return graphql.Null
 7470	}
 7471	res := resTmp.(*models.CommitPayload)
 7472	fc.Result = res
 7473	return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
 7474}
 7475
 7476func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7477	defer func() {
 7478		if r := recover(); r != nil {
 7479			ec.Error(ctx, ec.Recover(ctx, r))
 7480			ret = graphql.Null
 7481		}
 7482	}()
 7483	fc := &graphql.FieldContext{
 7484		Object:   "Mutation",
 7485		Field:    field,
 7486		Args:     nil,
 7487		IsMethod: true,
 7488	}
 7489
 7490	ctx = graphql.WithFieldContext(ctx, fc)
 7491	rawArgs := field.ArgumentMap(ec.Variables)
 7492	args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
 7493	if err != nil {
 7494		ec.Error(ctx, err)
 7495		return graphql.Null
 7496	}
 7497	fc.Args = args
 7498	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7499		ctx = rctx // use context from middleware stack in children
 7500		return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
 7501	})
 7502	if err != nil {
 7503		ec.Error(ctx, err)
 7504		return graphql.Null
 7505	}
 7506	if resTmp == nil {
 7507		if !graphql.HasFieldError(ctx, fc) {
 7508			ec.Errorf(ctx, "must not be null")
 7509		}
 7510		return graphql.Null
 7511	}
 7512	res := resTmp.(*models.CommitAsNeededPayload)
 7513	fc.Result = res
 7514	return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
 7515}
 7516
 7517func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7518	defer func() {
 7519		if r := recover(); r != nil {
 7520			ec.Error(ctx, ec.Recover(ctx, r))
 7521			ret = graphql.Null
 7522		}
 7523	}()
 7524	fc := &graphql.FieldContext{
 7525		Object:   "NewBugPayload",
 7526		Field:    field,
 7527		Args:     nil,
 7528		IsMethod: false,
 7529	}
 7530
 7531	ctx = graphql.WithFieldContext(ctx, fc)
 7532	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7533		ctx = rctx // use context from middleware stack in children
 7534		return obj.ClientMutationID, nil
 7535	})
 7536	if err != nil {
 7537		ec.Error(ctx, err)
 7538		return graphql.Null
 7539	}
 7540	if resTmp == nil {
 7541		return graphql.Null
 7542	}
 7543	res := resTmp.(*string)
 7544	fc.Result = res
 7545	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7546}
 7547
 7548func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7549	defer func() {
 7550		if r := recover(); r != nil {
 7551			ec.Error(ctx, ec.Recover(ctx, r))
 7552			ret = graphql.Null
 7553		}
 7554	}()
 7555	fc := &graphql.FieldContext{
 7556		Object:   "NewBugPayload",
 7557		Field:    field,
 7558		Args:     nil,
 7559		IsMethod: false,
 7560	}
 7561
 7562	ctx = graphql.WithFieldContext(ctx, fc)
 7563	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7564		ctx = rctx // use context from middleware stack in children
 7565		return obj.Bug, nil
 7566	})
 7567	if err != nil {
 7568		ec.Error(ctx, err)
 7569		return graphql.Null
 7570	}
 7571	if resTmp == nil {
 7572		if !graphql.HasFieldError(ctx, fc) {
 7573			ec.Errorf(ctx, "must not be null")
 7574		}
 7575		return graphql.Null
 7576	}
 7577	res := resTmp.(*bug.Snapshot)
 7578	fc.Result = res
 7579	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 7580}
 7581
 7582func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7583	defer func() {
 7584		if r := recover(); r != nil {
 7585			ec.Error(ctx, ec.Recover(ctx, r))
 7586			ret = graphql.Null
 7587		}
 7588	}()
 7589	fc := &graphql.FieldContext{
 7590		Object:   "NewBugPayload",
 7591		Field:    field,
 7592		Args:     nil,
 7593		IsMethod: false,
 7594	}
 7595
 7596	ctx = graphql.WithFieldContext(ctx, fc)
 7597	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7598		ctx = rctx // use context from middleware stack in children
 7599		return obj.Operation, nil
 7600	})
 7601	if err != nil {
 7602		ec.Error(ctx, err)
 7603		return graphql.Null
 7604	}
 7605	if resTmp == nil {
 7606		if !graphql.HasFieldError(ctx, fc) {
 7607			ec.Errorf(ctx, "must not be null")
 7608		}
 7609		return graphql.Null
 7610	}
 7611	res := resTmp.(*bug.CreateOperation)
 7612	fc.Result = res
 7613	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7614}
 7615
 7616func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7617	defer func() {
 7618		if r := recover(); r != nil {
 7619			ec.Error(ctx, ec.Recover(ctx, r))
 7620			ret = graphql.Null
 7621		}
 7622	}()
 7623	fc := &graphql.FieldContext{
 7624		Object:   "OpenBugPayload",
 7625		Field:    field,
 7626		Args:     nil,
 7627		IsMethod: false,
 7628	}
 7629
 7630	ctx = graphql.WithFieldContext(ctx, fc)
 7631	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7632		ctx = rctx // use context from middleware stack in children
 7633		return obj.ClientMutationID, nil
 7634	})
 7635	if err != nil {
 7636		ec.Error(ctx, err)
 7637		return graphql.Null
 7638	}
 7639	if resTmp == nil {
 7640		return graphql.Null
 7641	}
 7642	res := resTmp.(*string)
 7643	fc.Result = res
 7644	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7645}
 7646
 7647func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7648	defer func() {
 7649		if r := recover(); r != nil {
 7650			ec.Error(ctx, ec.Recover(ctx, r))
 7651			ret = graphql.Null
 7652		}
 7653	}()
 7654	fc := &graphql.FieldContext{
 7655		Object:   "OpenBugPayload",
 7656		Field:    field,
 7657		Args:     nil,
 7658		IsMethod: false,
 7659	}
 7660
 7661	ctx = graphql.WithFieldContext(ctx, fc)
 7662	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7663		ctx = rctx // use context from middleware stack in children
 7664		return obj.Bug, nil
 7665	})
 7666	if err != nil {
 7667		ec.Error(ctx, err)
 7668		return graphql.Null
 7669	}
 7670	if resTmp == nil {
 7671		if !graphql.HasFieldError(ctx, fc) {
 7672			ec.Errorf(ctx, "must not be null")
 7673		}
 7674		return graphql.Null
 7675	}
 7676	res := resTmp.(*bug.Snapshot)
 7677	fc.Result = res
 7678	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 7679}
 7680
 7681func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7682	defer func() {
 7683		if r := recover(); r != nil {
 7684			ec.Error(ctx, ec.Recover(ctx, r))
 7685			ret = graphql.Null
 7686		}
 7687	}()
 7688	fc := &graphql.FieldContext{
 7689		Object:   "OpenBugPayload",
 7690		Field:    field,
 7691		Args:     nil,
 7692		IsMethod: false,
 7693	}
 7694
 7695	ctx = graphql.WithFieldContext(ctx, fc)
 7696	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7697		ctx = rctx // use context from middleware stack in children
 7698		return obj.Operation, nil
 7699	})
 7700	if err != nil {
 7701		ec.Error(ctx, err)
 7702		return graphql.Null
 7703	}
 7704	if resTmp == nil {
 7705		if !graphql.HasFieldError(ctx, fc) {
 7706			ec.Errorf(ctx, "must not be null")
 7707		}
 7708		return graphql.Null
 7709	}
 7710	res := resTmp.(*bug.SetStatusOperation)
 7711	fc.Result = res
 7712	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7713}
 7714
 7715func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7716	defer func() {
 7717		if r := recover(); r != nil {
 7718			ec.Error(ctx, ec.Recover(ctx, r))
 7719			ret = graphql.Null
 7720		}
 7721	}()
 7722	fc := &graphql.FieldContext{
 7723		Object:   "OperationConnection",
 7724		Field:    field,
 7725		Args:     nil,
 7726		IsMethod: false,
 7727	}
 7728
 7729	ctx = graphql.WithFieldContext(ctx, fc)
 7730	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7731		ctx = rctx // use context from middleware stack in children
 7732		return obj.Edges, nil
 7733	})
 7734	if err != nil {
 7735		ec.Error(ctx, err)
 7736		return graphql.Null
 7737	}
 7738	if resTmp == nil {
 7739		if !graphql.HasFieldError(ctx, fc) {
 7740			ec.Errorf(ctx, "must not be null")
 7741		}
 7742		return graphql.Null
 7743	}
 7744	res := resTmp.([]*models.OperationEdge)
 7745	fc.Result = res
 7746	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7747}
 7748
 7749func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7750	defer func() {
 7751		if r := recover(); r != nil {
 7752			ec.Error(ctx, ec.Recover(ctx, r))
 7753			ret = graphql.Null
 7754		}
 7755	}()
 7756	fc := &graphql.FieldContext{
 7757		Object:   "OperationConnection",
 7758		Field:    field,
 7759		Args:     nil,
 7760		IsMethod: false,
 7761	}
 7762
 7763	ctx = graphql.WithFieldContext(ctx, fc)
 7764	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7765		ctx = rctx // use context from middleware stack in children
 7766		return obj.Nodes, nil
 7767	})
 7768	if err != nil {
 7769		ec.Error(ctx, err)
 7770		return graphql.Null
 7771	}
 7772	if resTmp == nil {
 7773		if !graphql.HasFieldError(ctx, fc) {
 7774			ec.Errorf(ctx, "must not be null")
 7775		}
 7776		return graphql.Null
 7777	}
 7778	res := resTmp.([]bug.Operation)
 7779	fc.Result = res
 7780	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7781}
 7782
 7783func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7784	defer func() {
 7785		if r := recover(); r != nil {
 7786			ec.Error(ctx, ec.Recover(ctx, r))
 7787			ret = graphql.Null
 7788		}
 7789	}()
 7790	fc := &graphql.FieldContext{
 7791		Object:   "OperationConnection",
 7792		Field:    field,
 7793		Args:     nil,
 7794		IsMethod: false,
 7795	}
 7796
 7797	ctx = graphql.WithFieldContext(ctx, fc)
 7798	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7799		ctx = rctx // use context from middleware stack in children
 7800		return obj.PageInfo, nil
 7801	})
 7802	if err != nil {
 7803		ec.Error(ctx, err)
 7804		return graphql.Null
 7805	}
 7806	if resTmp == nil {
 7807		if !graphql.HasFieldError(ctx, fc) {
 7808			ec.Errorf(ctx, "must not be null")
 7809		}
 7810		return graphql.Null
 7811	}
 7812	res := resTmp.(*models.PageInfo)
 7813	fc.Result = res
 7814	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7815}
 7816
 7817func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7818	defer func() {
 7819		if r := recover(); r != nil {
 7820			ec.Error(ctx, ec.Recover(ctx, r))
 7821			ret = graphql.Null
 7822		}
 7823	}()
 7824	fc := &graphql.FieldContext{
 7825		Object:   "OperationConnection",
 7826		Field:    field,
 7827		Args:     nil,
 7828		IsMethod: false,
 7829	}
 7830
 7831	ctx = graphql.WithFieldContext(ctx, fc)
 7832	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7833		ctx = rctx // use context from middleware stack in children
 7834		return obj.TotalCount, nil
 7835	})
 7836	if err != nil {
 7837		ec.Error(ctx, err)
 7838		return graphql.Null
 7839	}
 7840	if resTmp == nil {
 7841		if !graphql.HasFieldError(ctx, fc) {
 7842			ec.Errorf(ctx, "must not be null")
 7843		}
 7844		return graphql.Null
 7845	}
 7846	res := resTmp.(int)
 7847	fc.Result = res
 7848	return ec.marshalNInt2int(ctx, field.Selections, res)
 7849}
 7850
 7851func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7852	defer func() {
 7853		if r := recover(); r != nil {
 7854			ec.Error(ctx, ec.Recover(ctx, r))
 7855			ret = graphql.Null
 7856		}
 7857	}()
 7858	fc := &graphql.FieldContext{
 7859		Object:   "OperationEdge",
 7860		Field:    field,
 7861		Args:     nil,
 7862		IsMethod: false,
 7863	}
 7864
 7865	ctx = graphql.WithFieldContext(ctx, fc)
 7866	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7867		ctx = rctx // use context from middleware stack in children
 7868		return obj.Cursor, nil
 7869	})
 7870	if err != nil {
 7871		ec.Error(ctx, err)
 7872		return graphql.Null
 7873	}
 7874	if resTmp == nil {
 7875		if !graphql.HasFieldError(ctx, fc) {
 7876			ec.Errorf(ctx, "must not be null")
 7877		}
 7878		return graphql.Null
 7879	}
 7880	res := resTmp.(string)
 7881	fc.Result = res
 7882	return ec.marshalNString2string(ctx, field.Selections, res)
 7883}
 7884
 7885func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7886	defer func() {
 7887		if r := recover(); r != nil {
 7888			ec.Error(ctx, ec.Recover(ctx, r))
 7889			ret = graphql.Null
 7890		}
 7891	}()
 7892	fc := &graphql.FieldContext{
 7893		Object:   "OperationEdge",
 7894		Field:    field,
 7895		Args:     nil,
 7896		IsMethod: false,
 7897	}
 7898
 7899	ctx = graphql.WithFieldContext(ctx, fc)
 7900	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7901		ctx = rctx // use context from middleware stack in children
 7902		return obj.Node, nil
 7903	})
 7904	if err != nil {
 7905		ec.Error(ctx, err)
 7906		return graphql.Null
 7907	}
 7908	if resTmp == nil {
 7909		if !graphql.HasFieldError(ctx, fc) {
 7910			ec.Errorf(ctx, "must not be null")
 7911		}
 7912		return graphql.Null
 7913	}
 7914	res := resTmp.(bug.Operation)
 7915	fc.Result = res
 7916	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7917}
 7918
 7919func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7920	defer func() {
 7921		if r := recover(); r != nil {
 7922			ec.Error(ctx, ec.Recover(ctx, r))
 7923			ret = graphql.Null
 7924		}
 7925	}()
 7926	fc := &graphql.FieldContext{
 7927		Object:   "PageInfo",
 7928		Field:    field,
 7929		Args:     nil,
 7930		IsMethod: false,
 7931	}
 7932
 7933	ctx = graphql.WithFieldContext(ctx, fc)
 7934	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7935		ctx = rctx // use context from middleware stack in children
 7936		return obj.HasNextPage, nil
 7937	})
 7938	if err != nil {
 7939		ec.Error(ctx, err)
 7940		return graphql.Null
 7941	}
 7942	if resTmp == nil {
 7943		if !graphql.HasFieldError(ctx, fc) {
 7944			ec.Errorf(ctx, "must not be null")
 7945		}
 7946		return graphql.Null
 7947	}
 7948	res := resTmp.(bool)
 7949	fc.Result = res
 7950	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7951}
 7952
 7953func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7954	defer func() {
 7955		if r := recover(); r != nil {
 7956			ec.Error(ctx, ec.Recover(ctx, r))
 7957			ret = graphql.Null
 7958		}
 7959	}()
 7960	fc := &graphql.FieldContext{
 7961		Object:   "PageInfo",
 7962		Field:    field,
 7963		Args:     nil,
 7964		IsMethod: false,
 7965	}
 7966
 7967	ctx = graphql.WithFieldContext(ctx, fc)
 7968	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7969		ctx = rctx // use context from middleware stack in children
 7970		return obj.HasPreviousPage, nil
 7971	})
 7972	if err != nil {
 7973		ec.Error(ctx, err)
 7974		return graphql.Null
 7975	}
 7976	if resTmp == nil {
 7977		if !graphql.HasFieldError(ctx, fc) {
 7978			ec.Errorf(ctx, "must not be null")
 7979		}
 7980		return graphql.Null
 7981	}
 7982	res := resTmp.(bool)
 7983	fc.Result = res
 7984	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7985}
 7986
 7987func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7988	defer func() {
 7989		if r := recover(); r != nil {
 7990			ec.Error(ctx, ec.Recover(ctx, r))
 7991			ret = graphql.Null
 7992		}
 7993	}()
 7994	fc := &graphql.FieldContext{
 7995		Object:   "PageInfo",
 7996		Field:    field,
 7997		Args:     nil,
 7998		IsMethod: false,
 7999	}
 8000
 8001	ctx = graphql.WithFieldContext(ctx, fc)
 8002	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8003		ctx = rctx // use context from middleware stack in children
 8004		return obj.StartCursor, nil
 8005	})
 8006	if err != nil {
 8007		ec.Error(ctx, err)
 8008		return graphql.Null
 8009	}
 8010	if resTmp == nil {
 8011		if !graphql.HasFieldError(ctx, fc) {
 8012			ec.Errorf(ctx, "must not be null")
 8013		}
 8014		return graphql.Null
 8015	}
 8016	res := resTmp.(string)
 8017	fc.Result = res
 8018	return ec.marshalNString2string(ctx, field.Selections, res)
 8019}
 8020
 8021func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 8022	defer func() {
 8023		if r := recover(); r != nil {
 8024			ec.Error(ctx, ec.Recover(ctx, r))
 8025			ret = graphql.Null
 8026		}
 8027	}()
 8028	fc := &graphql.FieldContext{
 8029		Object:   "PageInfo",
 8030		Field:    field,
 8031		Args:     nil,
 8032		IsMethod: false,
 8033	}
 8034
 8035	ctx = graphql.WithFieldContext(ctx, fc)
 8036	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8037		ctx = rctx // use context from middleware stack in children
 8038		return obj.EndCursor, nil
 8039	})
 8040	if err != nil {
 8041		ec.Error(ctx, err)
 8042		return graphql.Null
 8043	}
 8044	if resTmp == nil {
 8045		if !graphql.HasFieldError(ctx, fc) {
 8046			ec.Errorf(ctx, "must not be null")
 8047		}
 8048		return graphql.Null
 8049	}
 8050	res := resTmp.(string)
 8051	fc.Result = res
 8052	return ec.marshalNString2string(ctx, field.Selections, res)
 8053}
 8054
 8055func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 8056	defer func() {
 8057		if r := recover(); r != nil {
 8058			ec.Error(ctx, ec.Recover(ctx, r))
 8059			ret = graphql.Null
 8060		}
 8061	}()
 8062	fc := &graphql.FieldContext{
 8063		Object:   "Query",
 8064		Field:    field,
 8065		Args:     nil,
 8066		IsMethod: true,
 8067	}
 8068
 8069	ctx = graphql.WithFieldContext(ctx, fc)
 8070	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8071		ctx = rctx // use context from middleware stack in children
 8072		return ec.resolvers.Query().DefaultRepository(rctx)
 8073	})
 8074	if err != nil {
 8075		ec.Error(ctx, err)
 8076		return graphql.Null
 8077	}
 8078	if resTmp == nil {
 8079		return graphql.Null
 8080	}
 8081	res := resTmp.(*models.Repository)
 8082	fc.Result = res
 8083	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 8084}
 8085
 8086func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 8087	defer func() {
 8088		if r := recover(); r != nil {
 8089			ec.Error(ctx, ec.Recover(ctx, r))
 8090			ret = graphql.Null
 8091		}
 8092	}()
 8093	fc := &graphql.FieldContext{
 8094		Object:   "Query",
 8095		Field:    field,
 8096		Args:     nil,
 8097		IsMethod: true,
 8098	}
 8099
 8100	ctx = graphql.WithFieldContext(ctx, fc)
 8101	rawArgs := field.ArgumentMap(ec.Variables)
 8102	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 8103	if err != nil {
 8104		ec.Error(ctx, err)
 8105		return graphql.Null
 8106	}
 8107	fc.Args = args
 8108	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8109		ctx = rctx // use context from middleware stack in children
 8110		return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
 8111	})
 8112	if err != nil {
 8113		ec.Error(ctx, err)
 8114		return graphql.Null
 8115	}
 8116	if resTmp == nil {
 8117		return graphql.Null
 8118	}
 8119	res := resTmp.(*models.Repository)
 8120	fc.Result = res
 8121	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 8122}
 8123
 8124func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 8125	defer func() {
 8126		if r := recover(); r != nil {
 8127			ec.Error(ctx, ec.Recover(ctx, r))
 8128			ret = graphql.Null
 8129		}
 8130	}()
 8131	fc := &graphql.FieldContext{
 8132		Object:   "Query",
 8133		Field:    field,
 8134		Args:     nil,
 8135		IsMethod: true,
 8136	}
 8137
 8138	ctx = graphql.WithFieldContext(ctx, fc)
 8139	rawArgs := field.ArgumentMap(ec.Variables)
 8140	args, err := ec.field_Query___type_args(ctx, rawArgs)
 8141	if err != nil {
 8142		ec.Error(ctx, err)
 8143		return graphql.Null
 8144	}
 8145	fc.Args = args
 8146	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8147		ctx = rctx // use context from middleware stack in children
 8148		return ec.introspectType(args["name"].(string))
 8149	})
 8150	if err != nil {
 8151		ec.Error(ctx, err)
 8152		return graphql.Null
 8153	}
 8154	if resTmp == nil {
 8155		return graphql.Null
 8156	}
 8157	res := resTmp.(*introspection.Type)
 8158	fc.Result = res
 8159	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8160}
 8161
 8162func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 8163	defer func() {
 8164		if r := recover(); r != nil {
 8165			ec.Error(ctx, ec.Recover(ctx, r))
 8166			ret = graphql.Null
 8167		}
 8168	}()
 8169	fc := &graphql.FieldContext{
 8170		Object:   "Query",
 8171		Field:    field,
 8172		Args:     nil,
 8173		IsMethod: true,
 8174	}
 8175
 8176	ctx = graphql.WithFieldContext(ctx, fc)
 8177	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8178		ctx = rctx // use context from middleware stack in children
 8179		return ec.introspectSchema()
 8180	})
 8181	if err != nil {
 8182		ec.Error(ctx, err)
 8183		return graphql.Null
 8184	}
 8185	if resTmp == nil {
 8186		return graphql.Null
 8187	}
 8188	res := resTmp.(*introspection.Schema)
 8189	fc.Result = res
 8190	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 8191}
 8192
 8193func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8194	defer func() {
 8195		if r := recover(); r != nil {
 8196			ec.Error(ctx, ec.Recover(ctx, r))
 8197			ret = graphql.Null
 8198		}
 8199	}()
 8200	fc := &graphql.FieldContext{
 8201		Object:   "Repository",
 8202		Field:    field,
 8203		Args:     nil,
 8204		IsMethod: true,
 8205	}
 8206
 8207	ctx = graphql.WithFieldContext(ctx, fc)
 8208	rawArgs := field.ArgumentMap(ec.Variables)
 8209	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 8210	if err != nil {
 8211		ec.Error(ctx, err)
 8212		return graphql.Null
 8213	}
 8214	fc.Args = args
 8215	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8216		ctx = rctx // use context from middleware stack in children
 8217		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 8218	})
 8219	if err != nil {
 8220		ec.Error(ctx, err)
 8221		return graphql.Null
 8222	}
 8223	if resTmp == nil {
 8224		if !graphql.HasFieldError(ctx, fc) {
 8225			ec.Errorf(ctx, "must not be null")
 8226		}
 8227		return graphql.Null
 8228	}
 8229	res := resTmp.(*models.BugConnection)
 8230	fc.Result = res
 8231	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 8232}
 8233
 8234func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8235	defer func() {
 8236		if r := recover(); r != nil {
 8237			ec.Error(ctx, ec.Recover(ctx, r))
 8238			ret = graphql.Null
 8239		}
 8240	}()
 8241	fc := &graphql.FieldContext{
 8242		Object:   "Repository",
 8243		Field:    field,
 8244		Args:     nil,
 8245		IsMethod: true,
 8246	}
 8247
 8248	ctx = graphql.WithFieldContext(ctx, fc)
 8249	rawArgs := field.ArgumentMap(ec.Variables)
 8250	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 8251	if err != nil {
 8252		ec.Error(ctx, err)
 8253		return graphql.Null
 8254	}
 8255	fc.Args = args
 8256	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8257		ctx = rctx // use context from middleware stack in children
 8258		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 8259	})
 8260	if err != nil {
 8261		ec.Error(ctx, err)
 8262		return graphql.Null
 8263	}
 8264	if resTmp == nil {
 8265		return graphql.Null
 8266	}
 8267	res := resTmp.(*bug.Snapshot)
 8268	fc.Result = res
 8269	return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 8270}
 8271
 8272func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8273	defer func() {
 8274		if r := recover(); r != nil {
 8275			ec.Error(ctx, ec.Recover(ctx, r))
 8276			ret = graphql.Null
 8277		}
 8278	}()
 8279	fc := &graphql.FieldContext{
 8280		Object:   "Repository",
 8281		Field:    field,
 8282		Args:     nil,
 8283		IsMethod: true,
 8284	}
 8285
 8286	ctx = graphql.WithFieldContext(ctx, fc)
 8287	rawArgs := field.ArgumentMap(ec.Variables)
 8288	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 8289	if err != nil {
 8290		ec.Error(ctx, err)
 8291		return graphql.Null
 8292	}
 8293	fc.Args = args
 8294	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8295		ctx = rctx // use context from middleware stack in children
 8296		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8297	})
 8298	if err != nil {
 8299		ec.Error(ctx, err)
 8300		return graphql.Null
 8301	}
 8302	if resTmp == nil {
 8303		if !graphql.HasFieldError(ctx, fc) {
 8304			ec.Errorf(ctx, "must not be null")
 8305		}
 8306		return graphql.Null
 8307	}
 8308	res := resTmp.(*models.IdentityConnection)
 8309	fc.Result = res
 8310	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 8311}
 8312
 8313func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8314	defer func() {
 8315		if r := recover(); r != nil {
 8316			ec.Error(ctx, ec.Recover(ctx, r))
 8317			ret = graphql.Null
 8318		}
 8319	}()
 8320	fc := &graphql.FieldContext{
 8321		Object:   "Repository",
 8322		Field:    field,
 8323		Args:     nil,
 8324		IsMethod: true,
 8325	}
 8326
 8327	ctx = graphql.WithFieldContext(ctx, fc)
 8328	rawArgs := field.ArgumentMap(ec.Variables)
 8329	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 8330	if err != nil {
 8331		ec.Error(ctx, err)
 8332		return graphql.Null
 8333	}
 8334	fc.Args = args
 8335	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8336		ctx = rctx // use context from middleware stack in children
 8337		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 8338	})
 8339	if err != nil {
 8340		ec.Error(ctx, err)
 8341		return graphql.Null
 8342	}
 8343	if resTmp == nil {
 8344		return graphql.Null
 8345	}
 8346	res := resTmp.(identity.Interface)
 8347	fc.Result = res
 8348	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8349}
 8350
 8351func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8352	defer func() {
 8353		if r := recover(); r != nil {
 8354			ec.Error(ctx, ec.Recover(ctx, r))
 8355			ret = graphql.Null
 8356		}
 8357	}()
 8358	fc := &graphql.FieldContext{
 8359		Object:   "Repository",
 8360		Field:    field,
 8361		Args:     nil,
 8362		IsMethod: true,
 8363	}
 8364
 8365	ctx = graphql.WithFieldContext(ctx, fc)
 8366	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8367		ctx = rctx // use context from middleware stack in children
 8368		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 8369	})
 8370	if err != nil {
 8371		ec.Error(ctx, err)
 8372		return graphql.Null
 8373	}
 8374	if resTmp == nil {
 8375		return graphql.Null
 8376	}
 8377	res := resTmp.(identity.Interface)
 8378	fc.Result = res
 8379	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8380}
 8381
 8382func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8383	defer func() {
 8384		if r := recover(); r != nil {
 8385			ec.Error(ctx, ec.Recover(ctx, r))
 8386			ret = graphql.Null
 8387		}
 8388	}()
 8389	fc := &graphql.FieldContext{
 8390		Object:   "Repository",
 8391		Field:    field,
 8392		Args:     nil,
 8393		IsMethod: true,
 8394	}
 8395
 8396	ctx = graphql.WithFieldContext(ctx, fc)
 8397	rawArgs := field.ArgumentMap(ec.Variables)
 8398	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 8399	if err != nil {
 8400		ec.Error(ctx, err)
 8401		return graphql.Null
 8402	}
 8403	fc.Args = args
 8404	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8405		ctx = rctx // use context from middleware stack in children
 8406		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8407	})
 8408	if err != nil {
 8409		ec.Error(ctx, err)
 8410		return graphql.Null
 8411	}
 8412	if resTmp == nil {
 8413		if !graphql.HasFieldError(ctx, fc) {
 8414			ec.Errorf(ctx, "must not be null")
 8415		}
 8416		return graphql.Null
 8417	}
 8418	res := resTmp.(*models.LabelConnection)
 8419	fc.Result = res
 8420	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 8421}
 8422
 8423func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8424	defer func() {
 8425		if r := recover(); r != nil {
 8426			ec.Error(ctx, ec.Recover(ctx, r))
 8427			ret = graphql.Null
 8428		}
 8429	}()
 8430	fc := &graphql.FieldContext{
 8431		Object:   "SetStatusOperation",
 8432		Field:    field,
 8433		Args:     nil,
 8434		IsMethod: true,
 8435	}
 8436
 8437	ctx = graphql.WithFieldContext(ctx, fc)
 8438	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8439		ctx = rctx // use context from middleware stack in children
 8440		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 8441	})
 8442	if err != nil {
 8443		ec.Error(ctx, err)
 8444		return graphql.Null
 8445	}
 8446	if resTmp == nil {
 8447		if !graphql.HasFieldError(ctx, fc) {
 8448			ec.Errorf(ctx, "must not be null")
 8449		}
 8450		return graphql.Null
 8451	}
 8452	res := resTmp.(string)
 8453	fc.Result = res
 8454	return ec.marshalNString2string(ctx, field.Selections, res)
 8455}
 8456
 8457func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8458	defer func() {
 8459		if r := recover(); r != nil {
 8460			ec.Error(ctx, ec.Recover(ctx, r))
 8461			ret = graphql.Null
 8462		}
 8463	}()
 8464	fc := &graphql.FieldContext{
 8465		Object:   "SetStatusOperation",
 8466		Field:    field,
 8467		Args:     nil,
 8468		IsMethod: false,
 8469	}
 8470
 8471	ctx = graphql.WithFieldContext(ctx, fc)
 8472	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8473		ctx = rctx // use context from middleware stack in children
 8474		return obj.Author, nil
 8475	})
 8476	if err != nil {
 8477		ec.Error(ctx, err)
 8478		return graphql.Null
 8479	}
 8480	if resTmp == nil {
 8481		if !graphql.HasFieldError(ctx, fc) {
 8482			ec.Errorf(ctx, "must not be null")
 8483		}
 8484		return graphql.Null
 8485	}
 8486	res := resTmp.(identity.Interface)
 8487	fc.Result = res
 8488	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8489}
 8490
 8491func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8492	defer func() {
 8493		if r := recover(); r != nil {
 8494			ec.Error(ctx, ec.Recover(ctx, r))
 8495			ret = graphql.Null
 8496		}
 8497	}()
 8498	fc := &graphql.FieldContext{
 8499		Object:   "SetStatusOperation",
 8500		Field:    field,
 8501		Args:     nil,
 8502		IsMethod: true,
 8503	}
 8504
 8505	ctx = graphql.WithFieldContext(ctx, fc)
 8506	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8507		ctx = rctx // use context from middleware stack in children
 8508		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 8509	})
 8510	if err != nil {
 8511		ec.Error(ctx, err)
 8512		return graphql.Null
 8513	}
 8514	if resTmp == nil {
 8515		if !graphql.HasFieldError(ctx, fc) {
 8516			ec.Errorf(ctx, "must not be null")
 8517		}
 8518		return graphql.Null
 8519	}
 8520	res := resTmp.(*time.Time)
 8521	fc.Result = res
 8522	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8523}
 8524
 8525func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8526	defer func() {
 8527		if r := recover(); r != nil {
 8528			ec.Error(ctx, ec.Recover(ctx, r))
 8529			ret = graphql.Null
 8530		}
 8531	}()
 8532	fc := &graphql.FieldContext{
 8533		Object:   "SetStatusOperation",
 8534		Field:    field,
 8535		Args:     nil,
 8536		IsMethod: true,
 8537	}
 8538
 8539	ctx = graphql.WithFieldContext(ctx, fc)
 8540	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8541		ctx = rctx // use context from middleware stack in children
 8542		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8543	})
 8544	if err != nil {
 8545		ec.Error(ctx, err)
 8546		return graphql.Null
 8547	}
 8548	if resTmp == nil {
 8549		if !graphql.HasFieldError(ctx, fc) {
 8550			ec.Errorf(ctx, "must not be null")
 8551		}
 8552		return graphql.Null
 8553	}
 8554	res := resTmp.(models.Status)
 8555	fc.Result = res
 8556	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8557}
 8558
 8559func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8560	defer func() {
 8561		if r := recover(); r != nil {
 8562			ec.Error(ctx, ec.Recover(ctx, r))
 8563			ret = graphql.Null
 8564		}
 8565	}()
 8566	fc := &graphql.FieldContext{
 8567		Object:   "SetStatusTimelineItem",
 8568		Field:    field,
 8569		Args:     nil,
 8570		IsMethod: true,
 8571	}
 8572
 8573	ctx = graphql.WithFieldContext(ctx, fc)
 8574	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8575		ctx = rctx // use context from middleware stack in children
 8576		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8577	})
 8578	if err != nil {
 8579		ec.Error(ctx, err)
 8580		return graphql.Null
 8581	}
 8582	if resTmp == nil {
 8583		if !graphql.HasFieldError(ctx, fc) {
 8584			ec.Errorf(ctx, "must not be null")
 8585		}
 8586		return graphql.Null
 8587	}
 8588	res := resTmp.(string)
 8589	fc.Result = res
 8590	return ec.marshalNString2string(ctx, field.Selections, res)
 8591}
 8592
 8593func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8594	defer func() {
 8595		if r := recover(); r != nil {
 8596			ec.Error(ctx, ec.Recover(ctx, r))
 8597			ret = graphql.Null
 8598		}
 8599	}()
 8600	fc := &graphql.FieldContext{
 8601		Object:   "SetStatusTimelineItem",
 8602		Field:    field,
 8603		Args:     nil,
 8604		IsMethod: false,
 8605	}
 8606
 8607	ctx = graphql.WithFieldContext(ctx, fc)
 8608	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8609		ctx = rctx // use context from middleware stack in children
 8610		return obj.Author, nil
 8611	})
 8612	if err != nil {
 8613		ec.Error(ctx, err)
 8614		return graphql.Null
 8615	}
 8616	if resTmp == nil {
 8617		if !graphql.HasFieldError(ctx, fc) {
 8618			ec.Errorf(ctx, "must not be null")
 8619		}
 8620		return graphql.Null
 8621	}
 8622	res := resTmp.(identity.Interface)
 8623	fc.Result = res
 8624	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8625}
 8626
 8627func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8628	defer func() {
 8629		if r := recover(); r != nil {
 8630			ec.Error(ctx, ec.Recover(ctx, r))
 8631			ret = graphql.Null
 8632		}
 8633	}()
 8634	fc := &graphql.FieldContext{
 8635		Object:   "SetStatusTimelineItem",
 8636		Field:    field,
 8637		Args:     nil,
 8638		IsMethod: true,
 8639	}
 8640
 8641	ctx = graphql.WithFieldContext(ctx, fc)
 8642	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8643		ctx = rctx // use context from middleware stack in children
 8644		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8645	})
 8646	if err != nil {
 8647		ec.Error(ctx, err)
 8648		return graphql.Null
 8649	}
 8650	if resTmp == nil {
 8651		if !graphql.HasFieldError(ctx, fc) {
 8652			ec.Errorf(ctx, "must not be null")
 8653		}
 8654		return graphql.Null
 8655	}
 8656	res := resTmp.(*time.Time)
 8657	fc.Result = res
 8658	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8659}
 8660
 8661func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8662	defer func() {
 8663		if r := recover(); r != nil {
 8664			ec.Error(ctx, ec.Recover(ctx, r))
 8665			ret = graphql.Null
 8666		}
 8667	}()
 8668	fc := &graphql.FieldContext{
 8669		Object:   "SetStatusTimelineItem",
 8670		Field:    field,
 8671		Args:     nil,
 8672		IsMethod: true,
 8673	}
 8674
 8675	ctx = graphql.WithFieldContext(ctx, fc)
 8676	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8677		ctx = rctx // use context from middleware stack in children
 8678		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8679	})
 8680	if err != nil {
 8681		ec.Error(ctx, err)
 8682		return graphql.Null
 8683	}
 8684	if resTmp == nil {
 8685		if !graphql.HasFieldError(ctx, fc) {
 8686			ec.Errorf(ctx, "must not be null")
 8687		}
 8688		return graphql.Null
 8689	}
 8690	res := resTmp.(models.Status)
 8691	fc.Result = res
 8692	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8693}
 8694
 8695func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8696	defer func() {
 8697		if r := recover(); r != nil {
 8698			ec.Error(ctx, ec.Recover(ctx, r))
 8699			ret = graphql.Null
 8700		}
 8701	}()
 8702	fc := &graphql.FieldContext{
 8703		Object:   "SetTitleOperation",
 8704		Field:    field,
 8705		Args:     nil,
 8706		IsMethod: true,
 8707	}
 8708
 8709	ctx = graphql.WithFieldContext(ctx, fc)
 8710	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8711		ctx = rctx // use context from middleware stack in children
 8712		return ec.resolvers.SetTitleOperation().ID(rctx, obj)
 8713	})
 8714	if err != nil {
 8715		ec.Error(ctx, err)
 8716		return graphql.Null
 8717	}
 8718	if resTmp == nil {
 8719		if !graphql.HasFieldError(ctx, fc) {
 8720			ec.Errorf(ctx, "must not be null")
 8721		}
 8722		return graphql.Null
 8723	}
 8724	res := resTmp.(string)
 8725	fc.Result = res
 8726	return ec.marshalNString2string(ctx, field.Selections, res)
 8727}
 8728
 8729func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8730	defer func() {
 8731		if r := recover(); r != nil {
 8732			ec.Error(ctx, ec.Recover(ctx, r))
 8733			ret = graphql.Null
 8734		}
 8735	}()
 8736	fc := &graphql.FieldContext{
 8737		Object:   "SetTitleOperation",
 8738		Field:    field,
 8739		Args:     nil,
 8740		IsMethod: false,
 8741	}
 8742
 8743	ctx = graphql.WithFieldContext(ctx, fc)
 8744	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8745		ctx = rctx // use context from middleware stack in children
 8746		return obj.Author, nil
 8747	})
 8748	if err != nil {
 8749		ec.Error(ctx, err)
 8750		return graphql.Null
 8751	}
 8752	if resTmp == nil {
 8753		if !graphql.HasFieldError(ctx, fc) {
 8754			ec.Errorf(ctx, "must not be null")
 8755		}
 8756		return graphql.Null
 8757	}
 8758	res := resTmp.(identity.Interface)
 8759	fc.Result = res
 8760	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8761}
 8762
 8763func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8764	defer func() {
 8765		if r := recover(); r != nil {
 8766			ec.Error(ctx, ec.Recover(ctx, r))
 8767			ret = graphql.Null
 8768		}
 8769	}()
 8770	fc := &graphql.FieldContext{
 8771		Object:   "SetTitleOperation",
 8772		Field:    field,
 8773		Args:     nil,
 8774		IsMethod: true,
 8775	}
 8776
 8777	ctx = graphql.WithFieldContext(ctx, fc)
 8778	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8779		ctx = rctx // use context from middleware stack in children
 8780		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8781	})
 8782	if err != nil {
 8783		ec.Error(ctx, err)
 8784		return graphql.Null
 8785	}
 8786	if resTmp == nil {
 8787		if !graphql.HasFieldError(ctx, fc) {
 8788			ec.Errorf(ctx, "must not be null")
 8789		}
 8790		return graphql.Null
 8791	}
 8792	res := resTmp.(*time.Time)
 8793	fc.Result = res
 8794	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8795}
 8796
 8797func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8798	defer func() {
 8799		if r := recover(); r != nil {
 8800			ec.Error(ctx, ec.Recover(ctx, r))
 8801			ret = graphql.Null
 8802		}
 8803	}()
 8804	fc := &graphql.FieldContext{
 8805		Object:   "SetTitleOperation",
 8806		Field:    field,
 8807		Args:     nil,
 8808		IsMethod: false,
 8809	}
 8810
 8811	ctx = graphql.WithFieldContext(ctx, fc)
 8812	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8813		ctx = rctx // use context from middleware stack in children
 8814		return obj.Title, nil
 8815	})
 8816	if err != nil {
 8817		ec.Error(ctx, err)
 8818		return graphql.Null
 8819	}
 8820	if resTmp == nil {
 8821		if !graphql.HasFieldError(ctx, fc) {
 8822			ec.Errorf(ctx, "must not be null")
 8823		}
 8824		return graphql.Null
 8825	}
 8826	res := resTmp.(string)
 8827	fc.Result = res
 8828	return ec.marshalNString2string(ctx, field.Selections, res)
 8829}
 8830
 8831func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8832	defer func() {
 8833		if r := recover(); r != nil {
 8834			ec.Error(ctx, ec.Recover(ctx, r))
 8835			ret = graphql.Null
 8836		}
 8837	}()
 8838	fc := &graphql.FieldContext{
 8839		Object:   "SetTitleOperation",
 8840		Field:    field,
 8841		Args:     nil,
 8842		IsMethod: false,
 8843	}
 8844
 8845	ctx = graphql.WithFieldContext(ctx, fc)
 8846	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8847		ctx = rctx // use context from middleware stack in children
 8848		return obj.Was, nil
 8849	})
 8850	if err != nil {
 8851		ec.Error(ctx, err)
 8852		return graphql.Null
 8853	}
 8854	if resTmp == nil {
 8855		if !graphql.HasFieldError(ctx, fc) {
 8856			ec.Errorf(ctx, "must not be null")
 8857		}
 8858		return graphql.Null
 8859	}
 8860	res := resTmp.(string)
 8861	fc.Result = res
 8862	return ec.marshalNString2string(ctx, field.Selections, res)
 8863}
 8864
 8865func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8866	defer func() {
 8867		if r := recover(); r != nil {
 8868			ec.Error(ctx, ec.Recover(ctx, r))
 8869			ret = graphql.Null
 8870		}
 8871	}()
 8872	fc := &graphql.FieldContext{
 8873		Object:   "SetTitlePayload",
 8874		Field:    field,
 8875		Args:     nil,
 8876		IsMethod: false,
 8877	}
 8878
 8879	ctx = graphql.WithFieldContext(ctx, fc)
 8880	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8881		ctx = rctx // use context from middleware stack in children
 8882		return obj.ClientMutationID, nil
 8883	})
 8884	if err != nil {
 8885		ec.Error(ctx, err)
 8886		return graphql.Null
 8887	}
 8888	if resTmp == nil {
 8889		return graphql.Null
 8890	}
 8891	res := resTmp.(*string)
 8892	fc.Result = res
 8893	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8894}
 8895
 8896func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8897	defer func() {
 8898		if r := recover(); r != nil {
 8899			ec.Error(ctx, ec.Recover(ctx, r))
 8900			ret = graphql.Null
 8901		}
 8902	}()
 8903	fc := &graphql.FieldContext{
 8904		Object:   "SetTitlePayload",
 8905		Field:    field,
 8906		Args:     nil,
 8907		IsMethod: false,
 8908	}
 8909
 8910	ctx = graphql.WithFieldContext(ctx, fc)
 8911	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8912		ctx = rctx // use context from middleware stack in children
 8913		return obj.Bug, nil
 8914	})
 8915	if err != nil {
 8916		ec.Error(ctx, err)
 8917		return graphql.Null
 8918	}
 8919	if resTmp == nil {
 8920		if !graphql.HasFieldError(ctx, fc) {
 8921			ec.Errorf(ctx, "must not be null")
 8922		}
 8923		return graphql.Null
 8924	}
 8925	res := resTmp.(*bug.Snapshot)
 8926	fc.Result = res
 8927	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 8928}
 8929
 8930func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8931	defer func() {
 8932		if r := recover(); r != nil {
 8933			ec.Error(ctx, ec.Recover(ctx, r))
 8934			ret = graphql.Null
 8935		}
 8936	}()
 8937	fc := &graphql.FieldContext{
 8938		Object:   "SetTitlePayload",
 8939		Field:    field,
 8940		Args:     nil,
 8941		IsMethod: false,
 8942	}
 8943
 8944	ctx = graphql.WithFieldContext(ctx, fc)
 8945	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8946		ctx = rctx // use context from middleware stack in children
 8947		return obj.Operation, nil
 8948	})
 8949	if err != nil {
 8950		ec.Error(ctx, err)
 8951		return graphql.Null
 8952	}
 8953	if resTmp == nil {
 8954		if !graphql.HasFieldError(ctx, fc) {
 8955			ec.Errorf(ctx, "must not be null")
 8956		}
 8957		return graphql.Null
 8958	}
 8959	res := resTmp.(*bug.SetTitleOperation)
 8960	fc.Result = res
 8961	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8962}
 8963
 8964func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8965	defer func() {
 8966		if r := recover(); r != nil {
 8967			ec.Error(ctx, ec.Recover(ctx, r))
 8968			ret = graphql.Null
 8969		}
 8970	}()
 8971	fc := &graphql.FieldContext{
 8972		Object:   "SetTitleTimelineItem",
 8973		Field:    field,
 8974		Args:     nil,
 8975		IsMethod: true,
 8976	}
 8977
 8978	ctx = graphql.WithFieldContext(ctx, fc)
 8979	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8980		ctx = rctx // use context from middleware stack in children
 8981		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8982	})
 8983	if err != nil {
 8984		ec.Error(ctx, err)
 8985		return graphql.Null
 8986	}
 8987	if resTmp == nil {
 8988		if !graphql.HasFieldError(ctx, fc) {
 8989			ec.Errorf(ctx, "must not be null")
 8990		}
 8991		return graphql.Null
 8992	}
 8993	res := resTmp.(string)
 8994	fc.Result = res
 8995	return ec.marshalNString2string(ctx, field.Selections, res)
 8996}
 8997
 8998func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8999	defer func() {
 9000		if r := recover(); r != nil {
 9001			ec.Error(ctx, ec.Recover(ctx, r))
 9002			ret = graphql.Null
 9003		}
 9004	}()
 9005	fc := &graphql.FieldContext{
 9006		Object:   "SetTitleTimelineItem",
 9007		Field:    field,
 9008		Args:     nil,
 9009		IsMethod: false,
 9010	}
 9011
 9012	ctx = graphql.WithFieldContext(ctx, fc)
 9013	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9014		ctx = rctx // use context from middleware stack in children
 9015		return obj.Author, nil
 9016	})
 9017	if err != nil {
 9018		ec.Error(ctx, err)
 9019		return graphql.Null
 9020	}
 9021	if resTmp == nil {
 9022		if !graphql.HasFieldError(ctx, fc) {
 9023			ec.Errorf(ctx, "must not be null")
 9024		}
 9025		return graphql.Null
 9026	}
 9027	res := resTmp.(identity.Interface)
 9028	fc.Result = res
 9029	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 9030}
 9031
 9032func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 9033	defer func() {
 9034		if r := recover(); r != nil {
 9035			ec.Error(ctx, ec.Recover(ctx, r))
 9036			ret = graphql.Null
 9037		}
 9038	}()
 9039	fc := &graphql.FieldContext{
 9040		Object:   "SetTitleTimelineItem",
 9041		Field:    field,
 9042		Args:     nil,
 9043		IsMethod: true,
 9044	}
 9045
 9046	ctx = graphql.WithFieldContext(ctx, fc)
 9047	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9048		ctx = rctx // use context from middleware stack in children
 9049		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 9050	})
 9051	if err != nil {
 9052		ec.Error(ctx, err)
 9053		return graphql.Null
 9054	}
 9055	if resTmp == nil {
 9056		if !graphql.HasFieldError(ctx, fc) {
 9057			ec.Errorf(ctx, "must not be null")
 9058		}
 9059		return graphql.Null
 9060	}
 9061	res := resTmp.(*time.Time)
 9062	fc.Result = res
 9063	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 9064}
 9065
 9066func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 9067	defer func() {
 9068		if r := recover(); r != nil {
 9069			ec.Error(ctx, ec.Recover(ctx, r))
 9070			ret = graphql.Null
 9071		}
 9072	}()
 9073	fc := &graphql.FieldContext{
 9074		Object:   "SetTitleTimelineItem",
 9075		Field:    field,
 9076		Args:     nil,
 9077		IsMethod: false,
 9078	}
 9079
 9080	ctx = graphql.WithFieldContext(ctx, fc)
 9081	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9082		ctx = rctx // use context from middleware stack in children
 9083		return obj.Title, nil
 9084	})
 9085	if err != nil {
 9086		ec.Error(ctx, err)
 9087		return graphql.Null
 9088	}
 9089	if resTmp == nil {
 9090		if !graphql.HasFieldError(ctx, fc) {
 9091			ec.Errorf(ctx, "must not be null")
 9092		}
 9093		return graphql.Null
 9094	}
 9095	res := resTmp.(string)
 9096	fc.Result = res
 9097	return ec.marshalNString2string(ctx, field.Selections, res)
 9098}
 9099
 9100func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 9101	defer func() {
 9102		if r := recover(); r != nil {
 9103			ec.Error(ctx, ec.Recover(ctx, r))
 9104			ret = graphql.Null
 9105		}
 9106	}()
 9107	fc := &graphql.FieldContext{
 9108		Object:   "SetTitleTimelineItem",
 9109		Field:    field,
 9110		Args:     nil,
 9111		IsMethod: false,
 9112	}
 9113
 9114	ctx = graphql.WithFieldContext(ctx, fc)
 9115	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9116		ctx = rctx // use context from middleware stack in children
 9117		return obj.Was, nil
 9118	})
 9119	if err != nil {
 9120		ec.Error(ctx, err)
 9121		return graphql.Null
 9122	}
 9123	if resTmp == nil {
 9124		if !graphql.HasFieldError(ctx, fc) {
 9125			ec.Errorf(ctx, "must not be null")
 9126		}
 9127		return graphql.Null
 9128	}
 9129	res := resTmp.(string)
 9130	fc.Result = res
 9131	return ec.marshalNString2string(ctx, field.Selections, res)
 9132}
 9133
 9134func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9135	defer func() {
 9136		if r := recover(); r != nil {
 9137			ec.Error(ctx, ec.Recover(ctx, r))
 9138			ret = graphql.Null
 9139		}
 9140	}()
 9141	fc := &graphql.FieldContext{
 9142		Object:   "TimelineItemConnection",
 9143		Field:    field,
 9144		Args:     nil,
 9145		IsMethod: false,
 9146	}
 9147
 9148	ctx = graphql.WithFieldContext(ctx, fc)
 9149	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9150		ctx = rctx // use context from middleware stack in children
 9151		return obj.Edges, nil
 9152	})
 9153	if err != nil {
 9154		ec.Error(ctx, err)
 9155		return graphql.Null
 9156	}
 9157	if resTmp == nil {
 9158		if !graphql.HasFieldError(ctx, fc) {
 9159			ec.Errorf(ctx, "must not be null")
 9160		}
 9161		return graphql.Null
 9162	}
 9163	res := resTmp.([]*models.TimelineItemEdge)
 9164	fc.Result = res
 9165	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 9166}
 9167
 9168func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9169	defer func() {
 9170		if r := recover(); r != nil {
 9171			ec.Error(ctx, ec.Recover(ctx, r))
 9172			ret = graphql.Null
 9173		}
 9174	}()
 9175	fc := &graphql.FieldContext{
 9176		Object:   "TimelineItemConnection",
 9177		Field:    field,
 9178		Args:     nil,
 9179		IsMethod: false,
 9180	}
 9181
 9182	ctx = graphql.WithFieldContext(ctx, fc)
 9183	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9184		ctx = rctx // use context from middleware stack in children
 9185		return obj.Nodes, nil
 9186	})
 9187	if err != nil {
 9188		ec.Error(ctx, err)
 9189		return graphql.Null
 9190	}
 9191	if resTmp == nil {
 9192		if !graphql.HasFieldError(ctx, fc) {
 9193			ec.Errorf(ctx, "must not be null")
 9194		}
 9195		return graphql.Null
 9196	}
 9197	res := resTmp.([]bug.TimelineItem)
 9198	fc.Result = res
 9199	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 9200}
 9201
 9202func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9203	defer func() {
 9204		if r := recover(); r != nil {
 9205			ec.Error(ctx, ec.Recover(ctx, r))
 9206			ret = graphql.Null
 9207		}
 9208	}()
 9209	fc := &graphql.FieldContext{
 9210		Object:   "TimelineItemConnection",
 9211		Field:    field,
 9212		Args:     nil,
 9213		IsMethod: false,
 9214	}
 9215
 9216	ctx = graphql.WithFieldContext(ctx, fc)
 9217	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9218		ctx = rctx // use context from middleware stack in children
 9219		return obj.PageInfo, nil
 9220	})
 9221	if err != nil {
 9222		ec.Error(ctx, err)
 9223		return graphql.Null
 9224	}
 9225	if resTmp == nil {
 9226		if !graphql.HasFieldError(ctx, fc) {
 9227			ec.Errorf(ctx, "must not be null")
 9228		}
 9229		return graphql.Null
 9230	}
 9231	res := resTmp.(*models.PageInfo)
 9232	fc.Result = res
 9233	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 9234}
 9235
 9236func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9237	defer func() {
 9238		if r := recover(); r != nil {
 9239			ec.Error(ctx, ec.Recover(ctx, r))
 9240			ret = graphql.Null
 9241		}
 9242	}()
 9243	fc := &graphql.FieldContext{
 9244		Object:   "TimelineItemConnection",
 9245		Field:    field,
 9246		Args:     nil,
 9247		IsMethod: false,
 9248	}
 9249
 9250	ctx = graphql.WithFieldContext(ctx, fc)
 9251	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9252		ctx = rctx // use context from middleware stack in children
 9253		return obj.TotalCount, nil
 9254	})
 9255	if err != nil {
 9256		ec.Error(ctx, err)
 9257		return graphql.Null
 9258	}
 9259	if resTmp == nil {
 9260		if !graphql.HasFieldError(ctx, fc) {
 9261			ec.Errorf(ctx, "must not be null")
 9262		}
 9263		return graphql.Null
 9264	}
 9265	res := resTmp.(int)
 9266	fc.Result = res
 9267	return ec.marshalNInt2int(ctx, field.Selections, res)
 9268}
 9269
 9270func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 9271	defer func() {
 9272		if r := recover(); r != nil {
 9273			ec.Error(ctx, ec.Recover(ctx, r))
 9274			ret = graphql.Null
 9275		}
 9276	}()
 9277	fc := &graphql.FieldContext{
 9278		Object:   "TimelineItemEdge",
 9279		Field:    field,
 9280		Args:     nil,
 9281		IsMethod: false,
 9282	}
 9283
 9284	ctx = graphql.WithFieldContext(ctx, fc)
 9285	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9286		ctx = rctx // use context from middleware stack in children
 9287		return obj.Cursor, nil
 9288	})
 9289	if err != nil {
 9290		ec.Error(ctx, err)
 9291		return graphql.Null
 9292	}
 9293	if resTmp == nil {
 9294		if !graphql.HasFieldError(ctx, fc) {
 9295			ec.Errorf(ctx, "must not be null")
 9296		}
 9297		return graphql.Null
 9298	}
 9299	res := resTmp.(string)
 9300	fc.Result = res
 9301	return ec.marshalNString2string(ctx, field.Selections, res)
 9302}
 9303
 9304func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 9305	defer func() {
 9306		if r := recover(); r != nil {
 9307			ec.Error(ctx, ec.Recover(ctx, r))
 9308			ret = graphql.Null
 9309		}
 9310	}()
 9311	fc := &graphql.FieldContext{
 9312		Object:   "TimelineItemEdge",
 9313		Field:    field,
 9314		Args:     nil,
 9315		IsMethod: false,
 9316	}
 9317
 9318	ctx = graphql.WithFieldContext(ctx, fc)
 9319	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9320		ctx = rctx // use context from middleware stack in children
 9321		return obj.Node, nil
 9322	})
 9323	if err != nil {
 9324		ec.Error(ctx, err)
 9325		return graphql.Null
 9326	}
 9327	if resTmp == nil {
 9328		if !graphql.HasFieldError(ctx, fc) {
 9329			ec.Errorf(ctx, "must not be null")
 9330		}
 9331		return graphql.Null
 9332	}
 9333	res := resTmp.(bug.TimelineItem)
 9334	fc.Result = res
 9335	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 9336}
 9337
 9338func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9339	defer func() {
 9340		if r := recover(); r != nil {
 9341			ec.Error(ctx, ec.Recover(ctx, r))
 9342			ret = graphql.Null
 9343		}
 9344	}()
 9345	fc := &graphql.FieldContext{
 9346		Object:   "__Directive",
 9347		Field:    field,
 9348		Args:     nil,
 9349		IsMethod: false,
 9350	}
 9351
 9352	ctx = graphql.WithFieldContext(ctx, fc)
 9353	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9354		ctx = rctx // use context from middleware stack in children
 9355		return obj.Name, nil
 9356	})
 9357	if err != nil {
 9358		ec.Error(ctx, err)
 9359		return graphql.Null
 9360	}
 9361	if resTmp == nil {
 9362		if !graphql.HasFieldError(ctx, fc) {
 9363			ec.Errorf(ctx, "must not be null")
 9364		}
 9365		return graphql.Null
 9366	}
 9367	res := resTmp.(string)
 9368	fc.Result = res
 9369	return ec.marshalNString2string(ctx, field.Selections, res)
 9370}
 9371
 9372func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9373	defer func() {
 9374		if r := recover(); r != nil {
 9375			ec.Error(ctx, ec.Recover(ctx, r))
 9376			ret = graphql.Null
 9377		}
 9378	}()
 9379	fc := &graphql.FieldContext{
 9380		Object:   "__Directive",
 9381		Field:    field,
 9382		Args:     nil,
 9383		IsMethod: false,
 9384	}
 9385
 9386	ctx = graphql.WithFieldContext(ctx, fc)
 9387	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9388		ctx = rctx // use context from middleware stack in children
 9389		return obj.Description, nil
 9390	})
 9391	if err != nil {
 9392		ec.Error(ctx, err)
 9393		return graphql.Null
 9394	}
 9395	if resTmp == nil {
 9396		return graphql.Null
 9397	}
 9398	res := resTmp.(string)
 9399	fc.Result = res
 9400	return ec.marshalOString2string(ctx, field.Selections, res)
 9401}
 9402
 9403func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9404	defer func() {
 9405		if r := recover(); r != nil {
 9406			ec.Error(ctx, ec.Recover(ctx, r))
 9407			ret = graphql.Null
 9408		}
 9409	}()
 9410	fc := &graphql.FieldContext{
 9411		Object:   "__Directive",
 9412		Field:    field,
 9413		Args:     nil,
 9414		IsMethod: false,
 9415	}
 9416
 9417	ctx = graphql.WithFieldContext(ctx, fc)
 9418	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9419		ctx = rctx // use context from middleware stack in children
 9420		return obj.Locations, nil
 9421	})
 9422	if err != nil {
 9423		ec.Error(ctx, err)
 9424		return graphql.Null
 9425	}
 9426	if resTmp == nil {
 9427		if !graphql.HasFieldError(ctx, fc) {
 9428			ec.Errorf(ctx, "must not be null")
 9429		}
 9430		return graphql.Null
 9431	}
 9432	res := resTmp.([]string)
 9433	fc.Result = res
 9434	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 9435}
 9436
 9437func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9438	defer func() {
 9439		if r := recover(); r != nil {
 9440			ec.Error(ctx, ec.Recover(ctx, r))
 9441			ret = graphql.Null
 9442		}
 9443	}()
 9444	fc := &graphql.FieldContext{
 9445		Object:   "__Directive",
 9446		Field:    field,
 9447		Args:     nil,
 9448		IsMethod: false,
 9449	}
 9450
 9451	ctx = graphql.WithFieldContext(ctx, fc)
 9452	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9453		ctx = rctx // use context from middleware stack in children
 9454		return obj.Args, nil
 9455	})
 9456	if err != nil {
 9457		ec.Error(ctx, err)
 9458		return graphql.Null
 9459	}
 9460	if resTmp == nil {
 9461		if !graphql.HasFieldError(ctx, fc) {
 9462			ec.Errorf(ctx, "must not be null")
 9463		}
 9464		return graphql.Null
 9465	}
 9466	res := resTmp.([]introspection.InputValue)
 9467	fc.Result = res
 9468	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9469}
 9470
 9471func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9472	defer func() {
 9473		if r := recover(); r != nil {
 9474			ec.Error(ctx, ec.Recover(ctx, r))
 9475			ret = graphql.Null
 9476		}
 9477	}()
 9478	fc := &graphql.FieldContext{
 9479		Object:   "__EnumValue",
 9480		Field:    field,
 9481		Args:     nil,
 9482		IsMethod: false,
 9483	}
 9484
 9485	ctx = graphql.WithFieldContext(ctx, fc)
 9486	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9487		ctx = rctx // use context from middleware stack in children
 9488		return obj.Name, nil
 9489	})
 9490	if err != nil {
 9491		ec.Error(ctx, err)
 9492		return graphql.Null
 9493	}
 9494	if resTmp == nil {
 9495		if !graphql.HasFieldError(ctx, fc) {
 9496			ec.Errorf(ctx, "must not be null")
 9497		}
 9498		return graphql.Null
 9499	}
 9500	res := resTmp.(string)
 9501	fc.Result = res
 9502	return ec.marshalNString2string(ctx, field.Selections, res)
 9503}
 9504
 9505func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9506	defer func() {
 9507		if r := recover(); r != nil {
 9508			ec.Error(ctx, ec.Recover(ctx, r))
 9509			ret = graphql.Null
 9510		}
 9511	}()
 9512	fc := &graphql.FieldContext{
 9513		Object:   "__EnumValue",
 9514		Field:    field,
 9515		Args:     nil,
 9516		IsMethod: false,
 9517	}
 9518
 9519	ctx = graphql.WithFieldContext(ctx, fc)
 9520	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9521		ctx = rctx // use context from middleware stack in children
 9522		return obj.Description, nil
 9523	})
 9524	if err != nil {
 9525		ec.Error(ctx, err)
 9526		return graphql.Null
 9527	}
 9528	if resTmp == nil {
 9529		return graphql.Null
 9530	}
 9531	res := resTmp.(string)
 9532	fc.Result = res
 9533	return ec.marshalOString2string(ctx, field.Selections, res)
 9534}
 9535
 9536func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9537	defer func() {
 9538		if r := recover(); r != nil {
 9539			ec.Error(ctx, ec.Recover(ctx, r))
 9540			ret = graphql.Null
 9541		}
 9542	}()
 9543	fc := &graphql.FieldContext{
 9544		Object:   "__EnumValue",
 9545		Field:    field,
 9546		Args:     nil,
 9547		IsMethod: true,
 9548	}
 9549
 9550	ctx = graphql.WithFieldContext(ctx, fc)
 9551	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9552		ctx = rctx // use context from middleware stack in children
 9553		return obj.IsDeprecated(), nil
 9554	})
 9555	if err != nil {
 9556		ec.Error(ctx, err)
 9557		return graphql.Null
 9558	}
 9559	if resTmp == nil {
 9560		if !graphql.HasFieldError(ctx, fc) {
 9561			ec.Errorf(ctx, "must not be null")
 9562		}
 9563		return graphql.Null
 9564	}
 9565	res := resTmp.(bool)
 9566	fc.Result = res
 9567	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9568}
 9569
 9570func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9571	defer func() {
 9572		if r := recover(); r != nil {
 9573			ec.Error(ctx, ec.Recover(ctx, r))
 9574			ret = graphql.Null
 9575		}
 9576	}()
 9577	fc := &graphql.FieldContext{
 9578		Object:   "__EnumValue",
 9579		Field:    field,
 9580		Args:     nil,
 9581		IsMethod: true,
 9582	}
 9583
 9584	ctx = graphql.WithFieldContext(ctx, fc)
 9585	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9586		ctx = rctx // use context from middleware stack in children
 9587		return obj.DeprecationReason(), nil
 9588	})
 9589	if err != nil {
 9590		ec.Error(ctx, err)
 9591		return graphql.Null
 9592	}
 9593	if resTmp == nil {
 9594		return graphql.Null
 9595	}
 9596	res := resTmp.(*string)
 9597	fc.Result = res
 9598	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9599}
 9600
 9601func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9602	defer func() {
 9603		if r := recover(); r != nil {
 9604			ec.Error(ctx, ec.Recover(ctx, r))
 9605			ret = graphql.Null
 9606		}
 9607	}()
 9608	fc := &graphql.FieldContext{
 9609		Object:   "__Field",
 9610		Field:    field,
 9611		Args:     nil,
 9612		IsMethod: false,
 9613	}
 9614
 9615	ctx = graphql.WithFieldContext(ctx, fc)
 9616	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9617		ctx = rctx // use context from middleware stack in children
 9618		return obj.Name, nil
 9619	})
 9620	if err != nil {
 9621		ec.Error(ctx, err)
 9622		return graphql.Null
 9623	}
 9624	if resTmp == nil {
 9625		if !graphql.HasFieldError(ctx, fc) {
 9626			ec.Errorf(ctx, "must not be null")
 9627		}
 9628		return graphql.Null
 9629	}
 9630	res := resTmp.(string)
 9631	fc.Result = res
 9632	return ec.marshalNString2string(ctx, field.Selections, res)
 9633}
 9634
 9635func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9636	defer func() {
 9637		if r := recover(); r != nil {
 9638			ec.Error(ctx, ec.Recover(ctx, r))
 9639			ret = graphql.Null
 9640		}
 9641	}()
 9642	fc := &graphql.FieldContext{
 9643		Object:   "__Field",
 9644		Field:    field,
 9645		Args:     nil,
 9646		IsMethod: false,
 9647	}
 9648
 9649	ctx = graphql.WithFieldContext(ctx, fc)
 9650	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9651		ctx = rctx // use context from middleware stack in children
 9652		return obj.Description, nil
 9653	})
 9654	if err != nil {
 9655		ec.Error(ctx, err)
 9656		return graphql.Null
 9657	}
 9658	if resTmp == nil {
 9659		return graphql.Null
 9660	}
 9661	res := resTmp.(string)
 9662	fc.Result = res
 9663	return ec.marshalOString2string(ctx, field.Selections, res)
 9664}
 9665
 9666func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9667	defer func() {
 9668		if r := recover(); r != nil {
 9669			ec.Error(ctx, ec.Recover(ctx, r))
 9670			ret = graphql.Null
 9671		}
 9672	}()
 9673	fc := &graphql.FieldContext{
 9674		Object:   "__Field",
 9675		Field:    field,
 9676		Args:     nil,
 9677		IsMethod: false,
 9678	}
 9679
 9680	ctx = graphql.WithFieldContext(ctx, fc)
 9681	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9682		ctx = rctx // use context from middleware stack in children
 9683		return obj.Args, nil
 9684	})
 9685	if err != nil {
 9686		ec.Error(ctx, err)
 9687		return graphql.Null
 9688	}
 9689	if resTmp == nil {
 9690		if !graphql.HasFieldError(ctx, fc) {
 9691			ec.Errorf(ctx, "must not be null")
 9692		}
 9693		return graphql.Null
 9694	}
 9695	res := resTmp.([]introspection.InputValue)
 9696	fc.Result = res
 9697	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9698}
 9699
 9700func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9701	defer func() {
 9702		if r := recover(); r != nil {
 9703			ec.Error(ctx, ec.Recover(ctx, r))
 9704			ret = graphql.Null
 9705		}
 9706	}()
 9707	fc := &graphql.FieldContext{
 9708		Object:   "__Field",
 9709		Field:    field,
 9710		Args:     nil,
 9711		IsMethod: false,
 9712	}
 9713
 9714	ctx = graphql.WithFieldContext(ctx, fc)
 9715	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9716		ctx = rctx // use context from middleware stack in children
 9717		return obj.Type, nil
 9718	})
 9719	if err != nil {
 9720		ec.Error(ctx, err)
 9721		return graphql.Null
 9722	}
 9723	if resTmp == nil {
 9724		if !graphql.HasFieldError(ctx, fc) {
 9725			ec.Errorf(ctx, "must not be null")
 9726		}
 9727		return graphql.Null
 9728	}
 9729	res := resTmp.(*introspection.Type)
 9730	fc.Result = res
 9731	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9732}
 9733
 9734func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9735	defer func() {
 9736		if r := recover(); r != nil {
 9737			ec.Error(ctx, ec.Recover(ctx, r))
 9738			ret = graphql.Null
 9739		}
 9740	}()
 9741	fc := &graphql.FieldContext{
 9742		Object:   "__Field",
 9743		Field:    field,
 9744		Args:     nil,
 9745		IsMethod: true,
 9746	}
 9747
 9748	ctx = graphql.WithFieldContext(ctx, fc)
 9749	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9750		ctx = rctx // use context from middleware stack in children
 9751		return obj.IsDeprecated(), nil
 9752	})
 9753	if err != nil {
 9754		ec.Error(ctx, err)
 9755		return graphql.Null
 9756	}
 9757	if resTmp == nil {
 9758		if !graphql.HasFieldError(ctx, fc) {
 9759			ec.Errorf(ctx, "must not be null")
 9760		}
 9761		return graphql.Null
 9762	}
 9763	res := resTmp.(bool)
 9764	fc.Result = res
 9765	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9766}
 9767
 9768func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9769	defer func() {
 9770		if r := recover(); r != nil {
 9771			ec.Error(ctx, ec.Recover(ctx, r))
 9772			ret = graphql.Null
 9773		}
 9774	}()
 9775	fc := &graphql.FieldContext{
 9776		Object:   "__Field",
 9777		Field:    field,
 9778		Args:     nil,
 9779		IsMethod: true,
 9780	}
 9781
 9782	ctx = graphql.WithFieldContext(ctx, fc)
 9783	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9784		ctx = rctx // use context from middleware stack in children
 9785		return obj.DeprecationReason(), nil
 9786	})
 9787	if err != nil {
 9788		ec.Error(ctx, err)
 9789		return graphql.Null
 9790	}
 9791	if resTmp == nil {
 9792		return graphql.Null
 9793	}
 9794	res := resTmp.(*string)
 9795	fc.Result = res
 9796	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9797}
 9798
 9799func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9800	defer func() {
 9801		if r := recover(); r != nil {
 9802			ec.Error(ctx, ec.Recover(ctx, r))
 9803			ret = graphql.Null
 9804		}
 9805	}()
 9806	fc := &graphql.FieldContext{
 9807		Object:   "__InputValue",
 9808		Field:    field,
 9809		Args:     nil,
 9810		IsMethod: false,
 9811	}
 9812
 9813	ctx = graphql.WithFieldContext(ctx, fc)
 9814	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9815		ctx = rctx // use context from middleware stack in children
 9816		return obj.Name, nil
 9817	})
 9818	if err != nil {
 9819		ec.Error(ctx, err)
 9820		return graphql.Null
 9821	}
 9822	if resTmp == nil {
 9823		if !graphql.HasFieldError(ctx, fc) {
 9824			ec.Errorf(ctx, "must not be null")
 9825		}
 9826		return graphql.Null
 9827	}
 9828	res := resTmp.(string)
 9829	fc.Result = res
 9830	return ec.marshalNString2string(ctx, field.Selections, res)
 9831}
 9832
 9833func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9834	defer func() {
 9835		if r := recover(); r != nil {
 9836			ec.Error(ctx, ec.Recover(ctx, r))
 9837			ret = graphql.Null
 9838		}
 9839	}()
 9840	fc := &graphql.FieldContext{
 9841		Object:   "__InputValue",
 9842		Field:    field,
 9843		Args:     nil,
 9844		IsMethod: false,
 9845	}
 9846
 9847	ctx = graphql.WithFieldContext(ctx, fc)
 9848	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9849		ctx = rctx // use context from middleware stack in children
 9850		return obj.Description, nil
 9851	})
 9852	if err != nil {
 9853		ec.Error(ctx, err)
 9854		return graphql.Null
 9855	}
 9856	if resTmp == nil {
 9857		return graphql.Null
 9858	}
 9859	res := resTmp.(string)
 9860	fc.Result = res
 9861	return ec.marshalOString2string(ctx, field.Selections, res)
 9862}
 9863
 9864func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9865	defer func() {
 9866		if r := recover(); r != nil {
 9867			ec.Error(ctx, ec.Recover(ctx, r))
 9868			ret = graphql.Null
 9869		}
 9870	}()
 9871	fc := &graphql.FieldContext{
 9872		Object:   "__InputValue",
 9873		Field:    field,
 9874		Args:     nil,
 9875		IsMethod: false,
 9876	}
 9877
 9878	ctx = graphql.WithFieldContext(ctx, fc)
 9879	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9880		ctx = rctx // use context from middleware stack in children
 9881		return obj.Type, nil
 9882	})
 9883	if err != nil {
 9884		ec.Error(ctx, err)
 9885		return graphql.Null
 9886	}
 9887	if resTmp == nil {
 9888		if !graphql.HasFieldError(ctx, fc) {
 9889			ec.Errorf(ctx, "must not be null")
 9890		}
 9891		return graphql.Null
 9892	}
 9893	res := resTmp.(*introspection.Type)
 9894	fc.Result = res
 9895	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9896}
 9897
 9898func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9899	defer func() {
 9900		if r := recover(); r != nil {
 9901			ec.Error(ctx, ec.Recover(ctx, r))
 9902			ret = graphql.Null
 9903		}
 9904	}()
 9905	fc := &graphql.FieldContext{
 9906		Object:   "__InputValue",
 9907		Field:    field,
 9908		Args:     nil,
 9909		IsMethod: false,
 9910	}
 9911
 9912	ctx = graphql.WithFieldContext(ctx, fc)
 9913	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9914		ctx = rctx // use context from middleware stack in children
 9915		return obj.DefaultValue, nil
 9916	})
 9917	if err != nil {
 9918		ec.Error(ctx, err)
 9919		return graphql.Null
 9920	}
 9921	if resTmp == nil {
 9922		return graphql.Null
 9923	}
 9924	res := resTmp.(*string)
 9925	fc.Result = res
 9926	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9927}
 9928
 9929func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9930	defer func() {
 9931		if r := recover(); r != nil {
 9932			ec.Error(ctx, ec.Recover(ctx, r))
 9933			ret = graphql.Null
 9934		}
 9935	}()
 9936	fc := &graphql.FieldContext{
 9937		Object:   "__Schema",
 9938		Field:    field,
 9939		Args:     nil,
 9940		IsMethod: true,
 9941	}
 9942
 9943	ctx = graphql.WithFieldContext(ctx, fc)
 9944	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9945		ctx = rctx // use context from middleware stack in children
 9946		return obj.Types(), nil
 9947	})
 9948	if err != nil {
 9949		ec.Error(ctx, err)
 9950		return graphql.Null
 9951	}
 9952	if resTmp == nil {
 9953		if !graphql.HasFieldError(ctx, fc) {
 9954			ec.Errorf(ctx, "must not be null")
 9955		}
 9956		return graphql.Null
 9957	}
 9958	res := resTmp.([]introspection.Type)
 9959	fc.Result = res
 9960	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9961}
 9962
 9963func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9964	defer func() {
 9965		if r := recover(); r != nil {
 9966			ec.Error(ctx, ec.Recover(ctx, r))
 9967			ret = graphql.Null
 9968		}
 9969	}()
 9970	fc := &graphql.FieldContext{
 9971		Object:   "__Schema",
 9972		Field:    field,
 9973		Args:     nil,
 9974		IsMethod: true,
 9975	}
 9976
 9977	ctx = graphql.WithFieldContext(ctx, fc)
 9978	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9979		ctx = rctx // use context from middleware stack in children
 9980		return obj.QueryType(), nil
 9981	})
 9982	if err != nil {
 9983		ec.Error(ctx, err)
 9984		return graphql.Null
 9985	}
 9986	if resTmp == nil {
 9987		if !graphql.HasFieldError(ctx, fc) {
 9988			ec.Errorf(ctx, "must not be null")
 9989		}
 9990		return graphql.Null
 9991	}
 9992	res := resTmp.(*introspection.Type)
 9993	fc.Result = res
 9994	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9995}
 9996
 9997func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9998	defer func() {
 9999		if r := recover(); r != nil {
10000			ec.Error(ctx, ec.Recover(ctx, r))
10001			ret = graphql.Null
10002		}
10003	}()
10004	fc := &graphql.FieldContext{
10005		Object:   "__Schema",
10006		Field:    field,
10007		Args:     nil,
10008		IsMethod: true,
10009	}
10010
10011	ctx = graphql.WithFieldContext(ctx, fc)
10012	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10013		ctx = rctx // use context from middleware stack in children
10014		return obj.MutationType(), nil
10015	})
10016	if err != nil {
10017		ec.Error(ctx, err)
10018		return graphql.Null
10019	}
10020	if resTmp == nil {
10021		return graphql.Null
10022	}
10023	res := resTmp.(*introspection.Type)
10024	fc.Result = res
10025	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10026}
10027
10028func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10029	defer func() {
10030		if r := recover(); r != nil {
10031			ec.Error(ctx, ec.Recover(ctx, r))
10032			ret = graphql.Null
10033		}
10034	}()
10035	fc := &graphql.FieldContext{
10036		Object:   "__Schema",
10037		Field:    field,
10038		Args:     nil,
10039		IsMethod: true,
10040	}
10041
10042	ctx = graphql.WithFieldContext(ctx, fc)
10043	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10044		ctx = rctx // use context from middleware stack in children
10045		return obj.SubscriptionType(), nil
10046	})
10047	if err != nil {
10048		ec.Error(ctx, err)
10049		return graphql.Null
10050	}
10051	if resTmp == nil {
10052		return graphql.Null
10053	}
10054	res := resTmp.(*introspection.Type)
10055	fc.Result = res
10056	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10057}
10058
10059func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10060	defer func() {
10061		if r := recover(); r != nil {
10062			ec.Error(ctx, ec.Recover(ctx, r))
10063			ret = graphql.Null
10064		}
10065	}()
10066	fc := &graphql.FieldContext{
10067		Object:   "__Schema",
10068		Field:    field,
10069		Args:     nil,
10070		IsMethod: true,
10071	}
10072
10073	ctx = graphql.WithFieldContext(ctx, fc)
10074	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10075		ctx = rctx // use context from middleware stack in children
10076		return obj.Directives(), nil
10077	})
10078	if err != nil {
10079		ec.Error(ctx, err)
10080		return graphql.Null
10081	}
10082	if resTmp == nil {
10083		if !graphql.HasFieldError(ctx, fc) {
10084			ec.Errorf(ctx, "must not be null")
10085		}
10086		return graphql.Null
10087	}
10088	res := resTmp.([]introspection.Directive)
10089	fc.Result = res
10090	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
10091}
10092
10093func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10094	defer func() {
10095		if r := recover(); r != nil {
10096			ec.Error(ctx, ec.Recover(ctx, r))
10097			ret = graphql.Null
10098		}
10099	}()
10100	fc := &graphql.FieldContext{
10101		Object:   "__Type",
10102		Field:    field,
10103		Args:     nil,
10104		IsMethod: true,
10105	}
10106
10107	ctx = graphql.WithFieldContext(ctx, fc)
10108	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10109		ctx = rctx // use context from middleware stack in children
10110		return obj.Kind(), nil
10111	})
10112	if err != nil {
10113		ec.Error(ctx, err)
10114		return graphql.Null
10115	}
10116	if resTmp == nil {
10117		if !graphql.HasFieldError(ctx, fc) {
10118			ec.Errorf(ctx, "must not be null")
10119		}
10120		return graphql.Null
10121	}
10122	res := resTmp.(string)
10123	fc.Result = res
10124	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10125}
10126
10127func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10128	defer func() {
10129		if r := recover(); r != nil {
10130			ec.Error(ctx, ec.Recover(ctx, r))
10131			ret = graphql.Null
10132		}
10133	}()
10134	fc := &graphql.FieldContext{
10135		Object:   "__Type",
10136		Field:    field,
10137		Args:     nil,
10138		IsMethod: true,
10139	}
10140
10141	ctx = graphql.WithFieldContext(ctx, fc)
10142	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10143		ctx = rctx // use context from middleware stack in children
10144		return obj.Name(), nil
10145	})
10146	if err != nil {
10147		ec.Error(ctx, err)
10148		return graphql.Null
10149	}
10150	if resTmp == nil {
10151		return graphql.Null
10152	}
10153	res := resTmp.(*string)
10154	fc.Result = res
10155	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10156}
10157
10158func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10159	defer func() {
10160		if r := recover(); r != nil {
10161			ec.Error(ctx, ec.Recover(ctx, r))
10162			ret = graphql.Null
10163		}
10164	}()
10165	fc := &graphql.FieldContext{
10166		Object:   "__Type",
10167		Field:    field,
10168		Args:     nil,
10169		IsMethod: true,
10170	}
10171
10172	ctx = graphql.WithFieldContext(ctx, fc)
10173	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10174		ctx = rctx // use context from middleware stack in children
10175		return obj.Description(), nil
10176	})
10177	if err != nil {
10178		ec.Error(ctx, err)
10179		return graphql.Null
10180	}
10181	if resTmp == nil {
10182		return graphql.Null
10183	}
10184	res := resTmp.(string)
10185	fc.Result = res
10186	return ec.marshalOString2string(ctx, field.Selections, res)
10187}
10188
10189func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10190	defer func() {
10191		if r := recover(); r != nil {
10192			ec.Error(ctx, ec.Recover(ctx, r))
10193			ret = graphql.Null
10194		}
10195	}()
10196	fc := &graphql.FieldContext{
10197		Object:   "__Type",
10198		Field:    field,
10199		Args:     nil,
10200		IsMethod: true,
10201	}
10202
10203	ctx = graphql.WithFieldContext(ctx, fc)
10204	rawArgs := field.ArgumentMap(ec.Variables)
10205	args, err := ec.field___Type_fields_args(ctx, rawArgs)
10206	if err != nil {
10207		ec.Error(ctx, err)
10208		return graphql.Null
10209	}
10210	fc.Args = args
10211	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10212		ctx = rctx // use context from middleware stack in children
10213		return obj.Fields(args["includeDeprecated"].(bool)), nil
10214	})
10215	if err != nil {
10216		ec.Error(ctx, err)
10217		return graphql.Null
10218	}
10219	if resTmp == nil {
10220		return graphql.Null
10221	}
10222	res := resTmp.([]introspection.Field)
10223	fc.Result = res
10224	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
10225}
10226
10227func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10228	defer func() {
10229		if r := recover(); r != nil {
10230			ec.Error(ctx, ec.Recover(ctx, r))
10231			ret = graphql.Null
10232		}
10233	}()
10234	fc := &graphql.FieldContext{
10235		Object:   "__Type",
10236		Field:    field,
10237		Args:     nil,
10238		IsMethod: true,
10239	}
10240
10241	ctx = graphql.WithFieldContext(ctx, fc)
10242	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10243		ctx = rctx // use context from middleware stack in children
10244		return obj.Interfaces(), nil
10245	})
10246	if err != nil {
10247		ec.Error(ctx, err)
10248		return graphql.Null
10249	}
10250	if resTmp == nil {
10251		return graphql.Null
10252	}
10253	res := resTmp.([]introspection.Type)
10254	fc.Result = res
10255	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10256}
10257
10258func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10259	defer func() {
10260		if r := recover(); r != nil {
10261			ec.Error(ctx, ec.Recover(ctx, r))
10262			ret = graphql.Null
10263		}
10264	}()
10265	fc := &graphql.FieldContext{
10266		Object:   "__Type",
10267		Field:    field,
10268		Args:     nil,
10269		IsMethod: true,
10270	}
10271
10272	ctx = graphql.WithFieldContext(ctx, fc)
10273	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10274		ctx = rctx // use context from middleware stack in children
10275		return obj.PossibleTypes(), nil
10276	})
10277	if err != nil {
10278		ec.Error(ctx, err)
10279		return graphql.Null
10280	}
10281	if resTmp == nil {
10282		return graphql.Null
10283	}
10284	res := resTmp.([]introspection.Type)
10285	fc.Result = res
10286	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10287}
10288
10289func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10290	defer func() {
10291		if r := recover(); r != nil {
10292			ec.Error(ctx, ec.Recover(ctx, r))
10293			ret = graphql.Null
10294		}
10295	}()
10296	fc := &graphql.FieldContext{
10297		Object:   "__Type",
10298		Field:    field,
10299		Args:     nil,
10300		IsMethod: true,
10301	}
10302
10303	ctx = graphql.WithFieldContext(ctx, fc)
10304	rawArgs := field.ArgumentMap(ec.Variables)
10305	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10306	if err != nil {
10307		ec.Error(ctx, err)
10308		return graphql.Null
10309	}
10310	fc.Args = args
10311	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10312		ctx = rctx // use context from middleware stack in children
10313		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10314	})
10315	if err != nil {
10316		ec.Error(ctx, err)
10317		return graphql.Null
10318	}
10319	if resTmp == nil {
10320		return graphql.Null
10321	}
10322	res := resTmp.([]introspection.EnumValue)
10323	fc.Result = res
10324	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10325}
10326
10327func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10328	defer func() {
10329		if r := recover(); r != nil {
10330			ec.Error(ctx, ec.Recover(ctx, r))
10331			ret = graphql.Null
10332		}
10333	}()
10334	fc := &graphql.FieldContext{
10335		Object:   "__Type",
10336		Field:    field,
10337		Args:     nil,
10338		IsMethod: true,
10339	}
10340
10341	ctx = graphql.WithFieldContext(ctx, fc)
10342	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10343		ctx = rctx // use context from middleware stack in children
10344		return obj.InputFields(), nil
10345	})
10346	if err != nil {
10347		ec.Error(ctx, err)
10348		return graphql.Null
10349	}
10350	if resTmp == nil {
10351		return graphql.Null
10352	}
10353	res := resTmp.([]introspection.InputValue)
10354	fc.Result = res
10355	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10356}
10357
10358func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10359	defer func() {
10360		if r := recover(); r != nil {
10361			ec.Error(ctx, ec.Recover(ctx, r))
10362			ret = graphql.Null
10363		}
10364	}()
10365	fc := &graphql.FieldContext{
10366		Object:   "__Type",
10367		Field:    field,
10368		Args:     nil,
10369		IsMethod: true,
10370	}
10371
10372	ctx = graphql.WithFieldContext(ctx, fc)
10373	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10374		ctx = rctx // use context from middleware stack in children
10375		return obj.OfType(), nil
10376	})
10377	if err != nil {
10378		ec.Error(ctx, err)
10379		return graphql.Null
10380	}
10381	if resTmp == nil {
10382		return graphql.Null
10383	}
10384	res := resTmp.(*introspection.Type)
10385	fc.Result = res
10386	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10387}
10388
10389// endregion **************************** field.gotpl *****************************
10390
10391// region    **************************** input.gotpl *****************************
10392
10393func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10394	var it models.AddCommentInput
10395	var asMap = obj.(map[string]interface{})
10396
10397	for k, v := range asMap {
10398		switch k {
10399		case "clientMutationId":
10400			var err error
10401			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10402			if err != nil {
10403				return it, err
10404			}
10405		case "repoRef":
10406			var err error
10407			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10408			if err != nil {
10409				return it, err
10410			}
10411		case "prefix":
10412			var err error
10413			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10414			if err != nil {
10415				return it, err
10416			}
10417		case "message":
10418			var err error
10419			it.Message, err = ec.unmarshalNString2string(ctx, v)
10420			if err != nil {
10421				return it, err
10422			}
10423		case "files":
10424			var err error
10425			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10426			if err != nil {
10427				return it, err
10428			}
10429		}
10430	}
10431
10432	return it, nil
10433}
10434
10435func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10436	var it models.ChangeLabelInput
10437	var asMap = obj.(map[string]interface{})
10438
10439	for k, v := range asMap {
10440		switch k {
10441		case "clientMutationId":
10442			var err error
10443			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10444			if err != nil {
10445				return it, err
10446			}
10447		case "repoRef":
10448			var err error
10449			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10450			if err != nil {
10451				return it, err
10452			}
10453		case "prefix":
10454			var err error
10455			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10456			if err != nil {
10457				return it, err
10458			}
10459		case "added":
10460			var err error
10461			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10462			if err != nil {
10463				return it, err
10464			}
10465		case "Removed":
10466			var err error
10467			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10468			if err != nil {
10469				return it, err
10470			}
10471		}
10472	}
10473
10474	return it, nil
10475}
10476
10477func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10478	var it models.CloseBugInput
10479	var asMap = obj.(map[string]interface{})
10480
10481	for k, v := range asMap {
10482		switch k {
10483		case "clientMutationId":
10484			var err error
10485			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10486			if err != nil {
10487				return it, err
10488			}
10489		case "repoRef":
10490			var err error
10491			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10492			if err != nil {
10493				return it, err
10494			}
10495		case "prefix":
10496			var err error
10497			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10498			if err != nil {
10499				return it, err
10500			}
10501		}
10502	}
10503
10504	return it, nil
10505}
10506
10507func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10508	var it models.CommitAsNeededInput
10509	var asMap = obj.(map[string]interface{})
10510
10511	for k, v := range asMap {
10512		switch k {
10513		case "clientMutationId":
10514			var err error
10515			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10516			if err != nil {
10517				return it, err
10518			}
10519		case "repoRef":
10520			var err error
10521			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10522			if err != nil {
10523				return it, err
10524			}
10525		case "prefix":
10526			var err error
10527			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10528			if err != nil {
10529				return it, err
10530			}
10531		}
10532	}
10533
10534	return it, nil
10535}
10536
10537func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10538	var it models.CommitInput
10539	var asMap = obj.(map[string]interface{})
10540
10541	for k, v := range asMap {
10542		switch k {
10543		case "clientMutationId":
10544			var err error
10545			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10546			if err != nil {
10547				return it, err
10548			}
10549		case "repoRef":
10550			var err error
10551			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10552			if err != nil {
10553				return it, err
10554			}
10555		case "prefix":
10556			var err error
10557			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10558			if err != nil {
10559				return it, err
10560			}
10561		}
10562	}
10563
10564	return it, nil
10565}
10566
10567func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10568	var it models.NewBugInput
10569	var asMap = obj.(map[string]interface{})
10570
10571	for k, v := range asMap {
10572		switch k {
10573		case "clientMutationId":
10574			var err error
10575			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10576			if err != nil {
10577				return it, err
10578			}
10579		case "repoRef":
10580			var err error
10581			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10582			if err != nil {
10583				return it, err
10584			}
10585		case "title":
10586			var err error
10587			it.Title, err = ec.unmarshalNString2string(ctx, v)
10588			if err != nil {
10589				return it, err
10590			}
10591		case "message":
10592			var err error
10593			it.Message, err = ec.unmarshalNString2string(ctx, v)
10594			if err != nil {
10595				return it, err
10596			}
10597		case "files":
10598			var err error
10599			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10600			if err != nil {
10601				return it, err
10602			}
10603		}
10604	}
10605
10606	return it, nil
10607}
10608
10609func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10610	var it models.OpenBugInput
10611	var asMap = obj.(map[string]interface{})
10612
10613	for k, v := range asMap {
10614		switch k {
10615		case "clientMutationId":
10616			var err error
10617			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10618			if err != nil {
10619				return it, err
10620			}
10621		case "repoRef":
10622			var err error
10623			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10624			if err != nil {
10625				return it, err
10626			}
10627		case "prefix":
10628			var err error
10629			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10630			if err != nil {
10631				return it, err
10632			}
10633		}
10634	}
10635
10636	return it, nil
10637}
10638
10639func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10640	var it models.SetTitleInput
10641	var asMap = obj.(map[string]interface{})
10642
10643	for k, v := range asMap {
10644		switch k {
10645		case "clientMutationId":
10646			var err error
10647			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10648			if err != nil {
10649				return it, err
10650			}
10651		case "repoRef":
10652			var err error
10653			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10654			if err != nil {
10655				return it, err
10656			}
10657		case "prefix":
10658			var err error
10659			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10660			if err != nil {
10661				return it, err
10662			}
10663		case "title":
10664			var err error
10665			it.Title, err = ec.unmarshalNString2string(ctx, v)
10666			if err != nil {
10667				return it, err
10668			}
10669		}
10670	}
10671
10672	return it, nil
10673}
10674
10675// endregion **************************** input.gotpl *****************************
10676
10677// region    ************************** interface.gotpl ***************************
10678
10679func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10680	switch obj := (obj).(type) {
10681	case nil:
10682		return graphql.Null
10683	case bug.Comment:
10684		return ec._Comment(ctx, sel, &obj)
10685	case *bug.Comment:
10686		if obj == nil {
10687			return graphql.Null
10688		}
10689		return ec._Comment(ctx, sel, obj)
10690	case *bug.Snapshot:
10691		if obj == nil {
10692			return graphql.Null
10693		}
10694		return ec._Bug(ctx, sel, obj)
10695	case *bug.CreateOperation:
10696		if obj == nil {
10697			return graphql.Null
10698		}
10699		return ec._CreateOperation(ctx, sel, obj)
10700	case *bug.SetTitleOperation:
10701		if obj == nil {
10702			return graphql.Null
10703		}
10704		return ec._SetTitleOperation(ctx, sel, obj)
10705	case *bug.AddCommentOperation:
10706		if obj == nil {
10707			return graphql.Null
10708		}
10709		return ec._AddCommentOperation(ctx, sel, obj)
10710	case *bug.EditCommentOperation:
10711		if obj == nil {
10712			return graphql.Null
10713		}
10714		return ec._EditCommentOperation(ctx, sel, obj)
10715	case *bug.SetStatusOperation:
10716		if obj == nil {
10717			return graphql.Null
10718		}
10719		return ec._SetStatusOperation(ctx, sel, obj)
10720	case *bug.LabelChangeOperation:
10721		if obj == nil {
10722			return graphql.Null
10723		}
10724		return ec._LabelChangeOperation(ctx, sel, obj)
10725	case *bug.CreateTimelineItem:
10726		if obj == nil {
10727			return graphql.Null
10728		}
10729		return ec._CreateTimelineItem(ctx, sel, obj)
10730	case *bug.AddCommentTimelineItem:
10731		if obj == nil {
10732			return graphql.Null
10733		}
10734		return ec._AddCommentTimelineItem(ctx, sel, obj)
10735	case *bug.LabelChangeTimelineItem:
10736		if obj == nil {
10737			return graphql.Null
10738		}
10739		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10740	case *bug.SetStatusTimelineItem:
10741		if obj == nil {
10742			return graphql.Null
10743		}
10744		return ec._SetStatusTimelineItem(ctx, sel, obj)
10745	case *bug.SetTitleTimelineItem:
10746		if obj == nil {
10747			return graphql.Null
10748		}
10749		return ec._SetTitleTimelineItem(ctx, sel, obj)
10750	default:
10751		panic(fmt.Errorf("unexpected type %T", obj))
10752	}
10753}
10754
10755func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10756	switch obj := (obj).(type) {
10757	case nil:
10758		return graphql.Null
10759	case *bug.CreateOperation:
10760		if obj == nil {
10761			return graphql.Null
10762		}
10763		return ec._CreateOperation(ctx, sel, obj)
10764	case *bug.SetTitleOperation:
10765		if obj == nil {
10766			return graphql.Null
10767		}
10768		return ec._SetTitleOperation(ctx, sel, obj)
10769	case *bug.AddCommentOperation:
10770		if obj == nil {
10771			return graphql.Null
10772		}
10773		return ec._AddCommentOperation(ctx, sel, obj)
10774	case *bug.EditCommentOperation:
10775		if obj == nil {
10776			return graphql.Null
10777		}
10778		return ec._EditCommentOperation(ctx, sel, obj)
10779	case *bug.SetStatusOperation:
10780		if obj == nil {
10781			return graphql.Null
10782		}
10783		return ec._SetStatusOperation(ctx, sel, obj)
10784	case *bug.LabelChangeOperation:
10785		if obj == nil {
10786			return graphql.Null
10787		}
10788		return ec._LabelChangeOperation(ctx, sel, obj)
10789	default:
10790		panic(fmt.Errorf("unexpected type %T", obj))
10791	}
10792}
10793
10794func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10795	switch obj := (obj).(type) {
10796	case nil:
10797		return graphql.Null
10798	case *bug.CreateTimelineItem:
10799		if obj == nil {
10800			return graphql.Null
10801		}
10802		return ec._CreateTimelineItem(ctx, sel, obj)
10803	case *bug.AddCommentTimelineItem:
10804		if obj == nil {
10805			return graphql.Null
10806		}
10807		return ec._AddCommentTimelineItem(ctx, sel, obj)
10808	case bug.LabelChangeTimelineItem:
10809		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10810	case *bug.LabelChangeTimelineItem:
10811		if obj == nil {
10812			return graphql.Null
10813		}
10814		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10815	case bug.SetStatusTimelineItem:
10816		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10817	case *bug.SetStatusTimelineItem:
10818		if obj == nil {
10819			return graphql.Null
10820		}
10821		return ec._SetStatusTimelineItem(ctx, sel, obj)
10822	case bug.SetTitleTimelineItem:
10823		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10824	case *bug.SetTitleTimelineItem:
10825		if obj == nil {
10826			return graphql.Null
10827		}
10828		return ec._SetTitleTimelineItem(ctx, sel, obj)
10829	default:
10830		panic(fmt.Errorf("unexpected type %T", obj))
10831	}
10832}
10833
10834// endregion ************************** interface.gotpl ***************************
10835
10836// region    **************************** object.gotpl ****************************
10837
10838var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10839
10840func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10841	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10842
10843	out := graphql.NewFieldSet(fields)
10844	var invalids uint32
10845	for i, field := range fields {
10846		switch field.Name {
10847		case "__typename":
10848			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10849		case "id":
10850			field := field
10851			out.Concurrently(i, func() (res graphql.Marshaler) {
10852				defer func() {
10853					if r := recover(); r != nil {
10854						ec.Error(ctx, ec.Recover(ctx, r))
10855					}
10856				}()
10857				res = ec._AddCommentOperation_id(ctx, field, obj)
10858				if res == graphql.Null {
10859					atomic.AddUint32(&invalids, 1)
10860				}
10861				return res
10862			})
10863		case "author":
10864			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
10865			if out.Values[i] == graphql.Null {
10866				atomic.AddUint32(&invalids, 1)
10867			}
10868		case "date":
10869			field := field
10870			out.Concurrently(i, func() (res graphql.Marshaler) {
10871				defer func() {
10872					if r := recover(); r != nil {
10873						ec.Error(ctx, ec.Recover(ctx, r))
10874					}
10875				}()
10876				res = ec._AddCommentOperation_date(ctx, field, obj)
10877				if res == graphql.Null {
10878					atomic.AddUint32(&invalids, 1)
10879				}
10880				return res
10881			})
10882		case "message":
10883			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10884			if out.Values[i] == graphql.Null {
10885				atomic.AddUint32(&invalids, 1)
10886			}
10887		case "files":
10888			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10889			if out.Values[i] == graphql.Null {
10890				atomic.AddUint32(&invalids, 1)
10891			}
10892		default:
10893			panic("unknown field " + strconv.Quote(field.Name))
10894		}
10895	}
10896	out.Dispatch()
10897	if invalids > 0 {
10898		return graphql.Null
10899	}
10900	return out
10901}
10902
10903var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10904
10905func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10906	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10907
10908	out := graphql.NewFieldSet(fields)
10909	var invalids uint32
10910	for i, field := range fields {
10911		switch field.Name {
10912		case "__typename":
10913			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10914		case "clientMutationId":
10915			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10916		case "bug":
10917			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10918			if out.Values[i] == graphql.Null {
10919				invalids++
10920			}
10921		case "operation":
10922			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10923			if out.Values[i] == graphql.Null {
10924				invalids++
10925			}
10926		default:
10927			panic("unknown field " + strconv.Quote(field.Name))
10928		}
10929	}
10930	out.Dispatch()
10931	if invalids > 0 {
10932		return graphql.Null
10933	}
10934	return out
10935}
10936
10937var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10938
10939func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10940	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10941
10942	out := graphql.NewFieldSet(fields)
10943	var invalids uint32
10944	for i, field := range fields {
10945		switch field.Name {
10946		case "__typename":
10947			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10948		case "id":
10949			field := field
10950			out.Concurrently(i, func() (res graphql.Marshaler) {
10951				defer func() {
10952					if r := recover(); r != nil {
10953						ec.Error(ctx, ec.Recover(ctx, r))
10954					}
10955				}()
10956				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10957				if res == graphql.Null {
10958					atomic.AddUint32(&invalids, 1)
10959				}
10960				return res
10961			})
10962		case "author":
10963			out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
10964			if out.Values[i] == graphql.Null {
10965				atomic.AddUint32(&invalids, 1)
10966			}
10967		case "message":
10968			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10969			if out.Values[i] == graphql.Null {
10970				atomic.AddUint32(&invalids, 1)
10971			}
10972		case "messageIsEmpty":
10973			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10974			if out.Values[i] == graphql.Null {
10975				atomic.AddUint32(&invalids, 1)
10976			}
10977		case "files":
10978			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10979			if out.Values[i] == graphql.Null {
10980				atomic.AddUint32(&invalids, 1)
10981			}
10982		case "createdAt":
10983			field := field
10984			out.Concurrently(i, func() (res graphql.Marshaler) {
10985				defer func() {
10986					if r := recover(); r != nil {
10987						ec.Error(ctx, ec.Recover(ctx, r))
10988					}
10989				}()
10990				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10991				if res == graphql.Null {
10992					atomic.AddUint32(&invalids, 1)
10993				}
10994				return res
10995			})
10996		case "lastEdit":
10997			field := field
10998			out.Concurrently(i, func() (res graphql.Marshaler) {
10999				defer func() {
11000					if r := recover(); r != nil {
11001						ec.Error(ctx, ec.Recover(ctx, r))
11002					}
11003				}()
11004				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
11005				if res == graphql.Null {
11006					atomic.AddUint32(&invalids, 1)
11007				}
11008				return res
11009			})
11010		case "edited":
11011			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
11012			if out.Values[i] == graphql.Null {
11013				atomic.AddUint32(&invalids, 1)
11014			}
11015		case "history":
11016			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
11017			if out.Values[i] == graphql.Null {
11018				atomic.AddUint32(&invalids, 1)
11019			}
11020		default:
11021			panic("unknown field " + strconv.Quote(field.Name))
11022		}
11023	}
11024	out.Dispatch()
11025	if invalids > 0 {
11026		return graphql.Null
11027	}
11028	return out
11029}
11030
11031var bugImplementors = []string{"Bug", "Authored"}
11032
11033func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
11034	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
11035
11036	out := graphql.NewFieldSet(fields)
11037	var invalids uint32
11038	for i, field := range fields {
11039		switch field.Name {
11040		case "__typename":
11041			out.Values[i] = graphql.MarshalString("Bug")
11042		case "id":
11043			field := field
11044			out.Concurrently(i, func() (res graphql.Marshaler) {
11045				defer func() {
11046					if r := recover(); r != nil {
11047						ec.Error(ctx, ec.Recover(ctx, r))
11048					}
11049				}()
11050				res = ec._Bug_id(ctx, field, obj)
11051				if res == graphql.Null {
11052					atomic.AddUint32(&invalids, 1)
11053				}
11054				return res
11055			})
11056		case "humanId":
11057			field := field
11058			out.Concurrently(i, func() (res graphql.Marshaler) {
11059				defer func() {
11060					if r := recover(); r != nil {
11061						ec.Error(ctx, ec.Recover(ctx, r))
11062					}
11063				}()
11064				res = ec._Bug_humanId(ctx, field, obj)
11065				if res == graphql.Null {
11066					atomic.AddUint32(&invalids, 1)
11067				}
11068				return res
11069			})
11070		case "status":
11071			field := field
11072			out.Concurrently(i, func() (res graphql.Marshaler) {
11073				defer func() {
11074					if r := recover(); r != nil {
11075						ec.Error(ctx, ec.Recover(ctx, r))
11076					}
11077				}()
11078				res = ec._Bug_status(ctx, field, obj)
11079				if res == graphql.Null {
11080					atomic.AddUint32(&invalids, 1)
11081				}
11082				return res
11083			})
11084		case "title":
11085			out.Values[i] = ec._Bug_title(ctx, field, obj)
11086			if out.Values[i] == graphql.Null {
11087				atomic.AddUint32(&invalids, 1)
11088			}
11089		case "labels":
11090			out.Values[i] = ec._Bug_labels(ctx, field, obj)
11091			if out.Values[i] == graphql.Null {
11092				atomic.AddUint32(&invalids, 1)
11093			}
11094		case "author":
11095			out.Values[i] = ec._Bug_author(ctx, field, obj)
11096			if out.Values[i] == graphql.Null {
11097				atomic.AddUint32(&invalids, 1)
11098			}
11099		case "createdAt":
11100			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11101			if out.Values[i] == graphql.Null {
11102				atomic.AddUint32(&invalids, 1)
11103			}
11104		case "lastEdit":
11105			field := field
11106			out.Concurrently(i, func() (res graphql.Marshaler) {
11107				defer func() {
11108					if r := recover(); r != nil {
11109						ec.Error(ctx, ec.Recover(ctx, r))
11110					}
11111				}()
11112				res = ec._Bug_lastEdit(ctx, field, obj)
11113				if res == graphql.Null {
11114					atomic.AddUint32(&invalids, 1)
11115				}
11116				return res
11117			})
11118		case "actors":
11119			field := field
11120			out.Concurrently(i, func() (res graphql.Marshaler) {
11121				defer func() {
11122					if r := recover(); r != nil {
11123						ec.Error(ctx, ec.Recover(ctx, r))
11124					}
11125				}()
11126				res = ec._Bug_actors(ctx, field, obj)
11127				if res == graphql.Null {
11128					atomic.AddUint32(&invalids, 1)
11129				}
11130				return res
11131			})
11132		case "participants":
11133			field := field
11134			out.Concurrently(i, func() (res graphql.Marshaler) {
11135				defer func() {
11136					if r := recover(); r != nil {
11137						ec.Error(ctx, ec.Recover(ctx, r))
11138					}
11139				}()
11140				res = ec._Bug_participants(ctx, field, obj)
11141				if res == graphql.Null {
11142					atomic.AddUint32(&invalids, 1)
11143				}
11144				return res
11145			})
11146		case "comments":
11147			field := field
11148			out.Concurrently(i, func() (res graphql.Marshaler) {
11149				defer func() {
11150					if r := recover(); r != nil {
11151						ec.Error(ctx, ec.Recover(ctx, r))
11152					}
11153				}()
11154				res = ec._Bug_comments(ctx, field, obj)
11155				if res == graphql.Null {
11156					atomic.AddUint32(&invalids, 1)
11157				}
11158				return res
11159			})
11160		case "timeline":
11161			field := field
11162			out.Concurrently(i, func() (res graphql.Marshaler) {
11163				defer func() {
11164					if r := recover(); r != nil {
11165						ec.Error(ctx, ec.Recover(ctx, r))
11166					}
11167				}()
11168				res = ec._Bug_timeline(ctx, field, obj)
11169				if res == graphql.Null {
11170					atomic.AddUint32(&invalids, 1)
11171				}
11172				return res
11173			})
11174		case "operations":
11175			field := field
11176			out.Concurrently(i, func() (res graphql.Marshaler) {
11177				defer func() {
11178					if r := recover(); r != nil {
11179						ec.Error(ctx, ec.Recover(ctx, r))
11180					}
11181				}()
11182				res = ec._Bug_operations(ctx, field, obj)
11183				if res == graphql.Null {
11184					atomic.AddUint32(&invalids, 1)
11185				}
11186				return res
11187			})
11188		default:
11189			panic("unknown field " + strconv.Quote(field.Name))
11190		}
11191	}
11192	out.Dispatch()
11193	if invalids > 0 {
11194		return graphql.Null
11195	}
11196	return out
11197}
11198
11199var bugConnectionImplementors = []string{"BugConnection"}
11200
11201func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11202	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
11203
11204	out := graphql.NewFieldSet(fields)
11205	var invalids uint32
11206	for i, field := range fields {
11207		switch field.Name {
11208		case "__typename":
11209			out.Values[i] = graphql.MarshalString("BugConnection")
11210		case "edges":
11211			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11212			if out.Values[i] == graphql.Null {
11213				invalids++
11214			}
11215		case "nodes":
11216			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11217			if out.Values[i] == graphql.Null {
11218				invalids++
11219			}
11220		case "pageInfo":
11221			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11222			if out.Values[i] == graphql.Null {
11223				invalids++
11224			}
11225		case "totalCount":
11226			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11227			if out.Values[i] == graphql.Null {
11228				invalids++
11229			}
11230		default:
11231			panic("unknown field " + strconv.Quote(field.Name))
11232		}
11233	}
11234	out.Dispatch()
11235	if invalids > 0 {
11236		return graphql.Null
11237	}
11238	return out
11239}
11240
11241var bugEdgeImplementors = []string{"BugEdge"}
11242
11243func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11244	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
11245
11246	out := graphql.NewFieldSet(fields)
11247	var invalids uint32
11248	for i, field := range fields {
11249		switch field.Name {
11250		case "__typename":
11251			out.Values[i] = graphql.MarshalString("BugEdge")
11252		case "cursor":
11253			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11254			if out.Values[i] == graphql.Null {
11255				invalids++
11256			}
11257		case "node":
11258			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11259			if out.Values[i] == graphql.Null {
11260				invalids++
11261			}
11262		default:
11263			panic("unknown field " + strconv.Quote(field.Name))
11264		}
11265	}
11266	out.Dispatch()
11267	if invalids > 0 {
11268		return graphql.Null
11269	}
11270	return out
11271}
11272
11273var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11274
11275func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11276	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11277
11278	out := graphql.NewFieldSet(fields)
11279	var invalids uint32
11280	for i, field := range fields {
11281		switch field.Name {
11282		case "__typename":
11283			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11284		case "clientMutationId":
11285			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11286		case "bug":
11287			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11288			if out.Values[i] == graphql.Null {
11289				invalids++
11290			}
11291		case "operation":
11292			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11293			if out.Values[i] == graphql.Null {
11294				invalids++
11295			}
11296		case "results":
11297			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11298			if out.Values[i] == graphql.Null {
11299				invalids++
11300			}
11301		default:
11302			panic("unknown field " + strconv.Quote(field.Name))
11303		}
11304	}
11305	out.Dispatch()
11306	if invalids > 0 {
11307		return graphql.Null
11308	}
11309	return out
11310}
11311
11312var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11313
11314func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11315	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11316
11317	out := graphql.NewFieldSet(fields)
11318	var invalids uint32
11319	for i, field := range fields {
11320		switch field.Name {
11321		case "__typename":
11322			out.Values[i] = graphql.MarshalString("CloseBugPayload")
11323		case "clientMutationId":
11324			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11325		case "bug":
11326			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11327			if out.Values[i] == graphql.Null {
11328				invalids++
11329			}
11330		case "operation":
11331			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11332			if out.Values[i] == graphql.Null {
11333				invalids++
11334			}
11335		default:
11336			panic("unknown field " + strconv.Quote(field.Name))
11337		}
11338	}
11339	out.Dispatch()
11340	if invalids > 0 {
11341		return graphql.Null
11342	}
11343	return out
11344}
11345
11346var colorImplementors = []string{"Color"}
11347
11348func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11349	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11350
11351	out := graphql.NewFieldSet(fields)
11352	var invalids uint32
11353	for i, field := range fields {
11354		switch field.Name {
11355		case "__typename":
11356			out.Values[i] = graphql.MarshalString("Color")
11357		case "R":
11358			field := field
11359			out.Concurrently(i, func() (res graphql.Marshaler) {
11360				defer func() {
11361					if r := recover(); r != nil {
11362						ec.Error(ctx, ec.Recover(ctx, r))
11363					}
11364				}()
11365				res = ec._Color_R(ctx, field, obj)
11366				if res == graphql.Null {
11367					atomic.AddUint32(&invalids, 1)
11368				}
11369				return res
11370			})
11371		case "G":
11372			field := field
11373			out.Concurrently(i, func() (res graphql.Marshaler) {
11374				defer func() {
11375					if r := recover(); r != nil {
11376						ec.Error(ctx, ec.Recover(ctx, r))
11377					}
11378				}()
11379				res = ec._Color_G(ctx, field, obj)
11380				if res == graphql.Null {
11381					atomic.AddUint32(&invalids, 1)
11382				}
11383				return res
11384			})
11385		case "B":
11386			field := field
11387			out.Concurrently(i, func() (res graphql.Marshaler) {
11388				defer func() {
11389					if r := recover(); r != nil {
11390						ec.Error(ctx, ec.Recover(ctx, r))
11391					}
11392				}()
11393				res = ec._Color_B(ctx, field, obj)
11394				if res == graphql.Null {
11395					atomic.AddUint32(&invalids, 1)
11396				}
11397				return res
11398			})
11399		default:
11400			panic("unknown field " + strconv.Quote(field.Name))
11401		}
11402	}
11403	out.Dispatch()
11404	if invalids > 0 {
11405		return graphql.Null
11406	}
11407	return out
11408}
11409
11410var commentImplementors = []string{"Comment", "Authored"}
11411
11412func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11413	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11414
11415	out := graphql.NewFieldSet(fields)
11416	var invalids uint32
11417	for i, field := range fields {
11418		switch field.Name {
11419		case "__typename":
11420			out.Values[i] = graphql.MarshalString("Comment")
11421		case "author":
11422			out.Values[i] = ec._Comment_author(ctx, field, obj)
11423			if out.Values[i] == graphql.Null {
11424				invalids++
11425			}
11426		case "message":
11427			out.Values[i] = ec._Comment_message(ctx, field, obj)
11428			if out.Values[i] == graphql.Null {
11429				invalids++
11430			}
11431		case "files":
11432			out.Values[i] = ec._Comment_files(ctx, field, obj)
11433			if out.Values[i] == graphql.Null {
11434				invalids++
11435			}
11436		default:
11437			panic("unknown field " + strconv.Quote(field.Name))
11438		}
11439	}
11440	out.Dispatch()
11441	if invalids > 0 {
11442		return graphql.Null
11443	}
11444	return out
11445}
11446
11447var commentConnectionImplementors = []string{"CommentConnection"}
11448
11449func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11450	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11451
11452	out := graphql.NewFieldSet(fields)
11453	var invalids uint32
11454	for i, field := range fields {
11455		switch field.Name {
11456		case "__typename":
11457			out.Values[i] = graphql.MarshalString("CommentConnection")
11458		case "edges":
11459			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11460			if out.Values[i] == graphql.Null {
11461				invalids++
11462			}
11463		case "nodes":
11464			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11465			if out.Values[i] == graphql.Null {
11466				invalids++
11467			}
11468		case "pageInfo":
11469			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11470			if out.Values[i] == graphql.Null {
11471				invalids++
11472			}
11473		case "totalCount":
11474			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11475			if out.Values[i] == graphql.Null {
11476				invalids++
11477			}
11478		default:
11479			panic("unknown field " + strconv.Quote(field.Name))
11480		}
11481	}
11482	out.Dispatch()
11483	if invalids > 0 {
11484		return graphql.Null
11485	}
11486	return out
11487}
11488
11489var commentEdgeImplementors = []string{"CommentEdge"}
11490
11491func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11492	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11493
11494	out := graphql.NewFieldSet(fields)
11495	var invalids uint32
11496	for i, field := range fields {
11497		switch field.Name {
11498		case "__typename":
11499			out.Values[i] = graphql.MarshalString("CommentEdge")
11500		case "cursor":
11501			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11502			if out.Values[i] == graphql.Null {
11503				invalids++
11504			}
11505		case "node":
11506			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11507			if out.Values[i] == graphql.Null {
11508				invalids++
11509			}
11510		default:
11511			panic("unknown field " + strconv.Quote(field.Name))
11512		}
11513	}
11514	out.Dispatch()
11515	if invalids > 0 {
11516		return graphql.Null
11517	}
11518	return out
11519}
11520
11521var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11522
11523func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11524	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11525
11526	out := graphql.NewFieldSet(fields)
11527	var invalids uint32
11528	for i, field := range fields {
11529		switch field.Name {
11530		case "__typename":
11531			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11532		case "message":
11533			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11534			if out.Values[i] == graphql.Null {
11535				atomic.AddUint32(&invalids, 1)
11536			}
11537		case "date":
11538			field := field
11539			out.Concurrently(i, func() (res graphql.Marshaler) {
11540				defer func() {
11541					if r := recover(); r != nil {
11542						ec.Error(ctx, ec.Recover(ctx, r))
11543					}
11544				}()
11545				res = ec._CommentHistoryStep_date(ctx, field, obj)
11546				if res == graphql.Null {
11547					atomic.AddUint32(&invalids, 1)
11548				}
11549				return res
11550			})
11551		default:
11552			panic("unknown field " + strconv.Quote(field.Name))
11553		}
11554	}
11555	out.Dispatch()
11556	if invalids > 0 {
11557		return graphql.Null
11558	}
11559	return out
11560}
11561
11562var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11563
11564func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11565	fields := graphql.CollectFields(ec.OperationContext, sel, commitAsNeededPayloadImplementors)
11566
11567	out := graphql.NewFieldSet(fields)
11568	var invalids uint32
11569	for i, field := range fields {
11570		switch field.Name {
11571		case "__typename":
11572			out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11573		case "clientMutationId":
11574			out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11575		case "bug":
11576			out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11577			if out.Values[i] == graphql.Null {
11578				invalids++
11579			}
11580		default:
11581			panic("unknown field " + strconv.Quote(field.Name))
11582		}
11583	}
11584	out.Dispatch()
11585	if invalids > 0 {
11586		return graphql.Null
11587	}
11588	return out
11589}
11590
11591var commitPayloadImplementors = []string{"CommitPayload"}
11592
11593func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11594	fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11595
11596	out := graphql.NewFieldSet(fields)
11597	var invalids uint32
11598	for i, field := range fields {
11599		switch field.Name {
11600		case "__typename":
11601			out.Values[i] = graphql.MarshalString("CommitPayload")
11602		case "clientMutationId":
11603			out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11604		case "bug":
11605			out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11606			if out.Values[i] == graphql.Null {
11607				invalids++
11608			}
11609		default:
11610			panic("unknown field " + strconv.Quote(field.Name))
11611		}
11612	}
11613	out.Dispatch()
11614	if invalids > 0 {
11615		return graphql.Null
11616	}
11617	return out
11618}
11619
11620var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11621
11622func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11623	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11624
11625	out := graphql.NewFieldSet(fields)
11626	var invalids uint32
11627	for i, field := range fields {
11628		switch field.Name {
11629		case "__typename":
11630			out.Values[i] = graphql.MarshalString("CreateOperation")
11631		case "id":
11632			field := field
11633			out.Concurrently(i, func() (res graphql.Marshaler) {
11634				defer func() {
11635					if r := recover(); r != nil {
11636						ec.Error(ctx, ec.Recover(ctx, r))
11637					}
11638				}()
11639				res = ec._CreateOperation_id(ctx, field, obj)
11640				if res == graphql.Null {
11641					atomic.AddUint32(&invalids, 1)
11642				}
11643				return res
11644			})
11645		case "author":
11646			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
11647			if out.Values[i] == graphql.Null {
11648				atomic.AddUint32(&invalids, 1)
11649			}
11650		case "date":
11651			field := field
11652			out.Concurrently(i, func() (res graphql.Marshaler) {
11653				defer func() {
11654					if r := recover(); r != nil {
11655						ec.Error(ctx, ec.Recover(ctx, r))
11656					}
11657				}()
11658				res = ec._CreateOperation_date(ctx, field, obj)
11659				if res == graphql.Null {
11660					atomic.AddUint32(&invalids, 1)
11661				}
11662				return res
11663			})
11664		case "title":
11665			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11666			if out.Values[i] == graphql.Null {
11667				atomic.AddUint32(&invalids, 1)
11668			}
11669		case "message":
11670			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11671			if out.Values[i] == graphql.Null {
11672				atomic.AddUint32(&invalids, 1)
11673			}
11674		case "files":
11675			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11676			if out.Values[i] == graphql.Null {
11677				atomic.AddUint32(&invalids, 1)
11678			}
11679		default:
11680			panic("unknown field " + strconv.Quote(field.Name))
11681		}
11682	}
11683	out.Dispatch()
11684	if invalids > 0 {
11685		return graphql.Null
11686	}
11687	return out
11688}
11689
11690var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11691
11692func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11693	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11694
11695	out := graphql.NewFieldSet(fields)
11696	var invalids uint32
11697	for i, field := range fields {
11698		switch field.Name {
11699		case "__typename":
11700			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11701		case "id":
11702			field := field
11703			out.Concurrently(i, func() (res graphql.Marshaler) {
11704				defer func() {
11705					if r := recover(); r != nil {
11706						ec.Error(ctx, ec.Recover(ctx, r))
11707					}
11708				}()
11709				res = ec._CreateTimelineItem_id(ctx, field, obj)
11710				if res == graphql.Null {
11711					atomic.AddUint32(&invalids, 1)
11712				}
11713				return res
11714			})
11715		case "author":
11716			out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
11717			if out.Values[i] == graphql.Null {
11718				atomic.AddUint32(&invalids, 1)
11719			}
11720		case "message":
11721			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11722			if out.Values[i] == graphql.Null {
11723				atomic.AddUint32(&invalids, 1)
11724			}
11725		case "messageIsEmpty":
11726			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11727			if out.Values[i] == graphql.Null {
11728				atomic.AddUint32(&invalids, 1)
11729			}
11730		case "files":
11731			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11732			if out.Values[i] == graphql.Null {
11733				atomic.AddUint32(&invalids, 1)
11734			}
11735		case "createdAt":
11736			field := field
11737			out.Concurrently(i, func() (res graphql.Marshaler) {
11738				defer func() {
11739					if r := recover(); r != nil {
11740						ec.Error(ctx, ec.Recover(ctx, r))
11741					}
11742				}()
11743				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11744				if res == graphql.Null {
11745					atomic.AddUint32(&invalids, 1)
11746				}
11747				return res
11748			})
11749		case "lastEdit":
11750			field := field
11751			out.Concurrently(i, func() (res graphql.Marshaler) {
11752				defer func() {
11753					if r := recover(); r != nil {
11754						ec.Error(ctx, ec.Recover(ctx, r))
11755					}
11756				}()
11757				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11758				if res == graphql.Null {
11759					atomic.AddUint32(&invalids, 1)
11760				}
11761				return res
11762			})
11763		case "edited":
11764			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11765			if out.Values[i] == graphql.Null {
11766				atomic.AddUint32(&invalids, 1)
11767			}
11768		case "history":
11769			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11770			if out.Values[i] == graphql.Null {
11771				atomic.AddUint32(&invalids, 1)
11772			}
11773		default:
11774			panic("unknown field " + strconv.Quote(field.Name))
11775		}
11776	}
11777	out.Dispatch()
11778	if invalids > 0 {
11779		return graphql.Null
11780	}
11781	return out
11782}
11783
11784var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11785
11786func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11787	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11788
11789	out := graphql.NewFieldSet(fields)
11790	var invalids uint32
11791	for i, field := range fields {
11792		switch field.Name {
11793		case "__typename":
11794			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11795		case "id":
11796			field := field
11797			out.Concurrently(i, func() (res graphql.Marshaler) {
11798				defer func() {
11799					if r := recover(); r != nil {
11800						ec.Error(ctx, ec.Recover(ctx, r))
11801					}
11802				}()
11803				res = ec._EditCommentOperation_id(ctx, field, obj)
11804				if res == graphql.Null {
11805					atomic.AddUint32(&invalids, 1)
11806				}
11807				return res
11808			})
11809		case "author":
11810			out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
11811			if out.Values[i] == graphql.Null {
11812				atomic.AddUint32(&invalids, 1)
11813			}
11814		case "date":
11815			field := field
11816			out.Concurrently(i, func() (res graphql.Marshaler) {
11817				defer func() {
11818					if r := recover(); r != nil {
11819						ec.Error(ctx, ec.Recover(ctx, r))
11820					}
11821				}()
11822				res = ec._EditCommentOperation_date(ctx, field, obj)
11823				if res == graphql.Null {
11824					atomic.AddUint32(&invalids, 1)
11825				}
11826				return res
11827			})
11828		case "target":
11829			field := field
11830			out.Concurrently(i, func() (res graphql.Marshaler) {
11831				defer func() {
11832					if r := recover(); r != nil {
11833						ec.Error(ctx, ec.Recover(ctx, r))
11834					}
11835				}()
11836				res = ec._EditCommentOperation_target(ctx, field, obj)
11837				if res == graphql.Null {
11838					atomic.AddUint32(&invalids, 1)
11839				}
11840				return res
11841			})
11842		case "message":
11843			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11844			if out.Values[i] == graphql.Null {
11845				atomic.AddUint32(&invalids, 1)
11846			}
11847		case "files":
11848			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11849			if out.Values[i] == graphql.Null {
11850				atomic.AddUint32(&invalids, 1)
11851			}
11852		default:
11853			panic("unknown field " + strconv.Quote(field.Name))
11854		}
11855	}
11856	out.Dispatch()
11857	if invalids > 0 {
11858		return graphql.Null
11859	}
11860	return out
11861}
11862
11863var identityImplementors = []string{"Identity"}
11864
11865func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj identity.Interface) graphql.Marshaler {
11866	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11867
11868	out := graphql.NewFieldSet(fields)
11869	var invalids uint32
11870	for i, field := range fields {
11871		switch field.Name {
11872		case "__typename":
11873			out.Values[i] = graphql.MarshalString("Identity")
11874		case "id":
11875			field := field
11876			out.Concurrently(i, func() (res graphql.Marshaler) {
11877				defer func() {
11878					if r := recover(); r != nil {
11879						ec.Error(ctx, ec.Recover(ctx, r))
11880					}
11881				}()
11882				res = ec._Identity_id(ctx, field, obj)
11883				if res == graphql.Null {
11884					atomic.AddUint32(&invalids, 1)
11885				}
11886				return res
11887			})
11888		case "humanId":
11889			field := field
11890			out.Concurrently(i, func() (res graphql.Marshaler) {
11891				defer func() {
11892					if r := recover(); r != nil {
11893						ec.Error(ctx, ec.Recover(ctx, r))
11894					}
11895				}()
11896				res = ec._Identity_humanId(ctx, field, obj)
11897				if res == graphql.Null {
11898					atomic.AddUint32(&invalids, 1)
11899				}
11900				return res
11901			})
11902		case "name":
11903			out.Values[i] = ec._Identity_name(ctx, field, obj)
11904		case "email":
11905			out.Values[i] = ec._Identity_email(ctx, field, obj)
11906		case "displayName":
11907			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11908			if out.Values[i] == graphql.Null {
11909				atomic.AddUint32(&invalids, 1)
11910			}
11911		case "avatarUrl":
11912			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11913		case "isProtected":
11914			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11915			if out.Values[i] == graphql.Null {
11916				atomic.AddUint32(&invalids, 1)
11917			}
11918		default:
11919			panic("unknown field " + strconv.Quote(field.Name))
11920		}
11921	}
11922	out.Dispatch()
11923	if invalids > 0 {
11924		return graphql.Null
11925	}
11926	return out
11927}
11928
11929var identityConnectionImplementors = []string{"IdentityConnection"}
11930
11931func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11932	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11933
11934	out := graphql.NewFieldSet(fields)
11935	var invalids uint32
11936	for i, field := range fields {
11937		switch field.Name {
11938		case "__typename":
11939			out.Values[i] = graphql.MarshalString("IdentityConnection")
11940		case "edges":
11941			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11942			if out.Values[i] == graphql.Null {
11943				invalids++
11944			}
11945		case "nodes":
11946			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11947			if out.Values[i] == graphql.Null {
11948				invalids++
11949			}
11950		case "pageInfo":
11951			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11952			if out.Values[i] == graphql.Null {
11953				invalids++
11954			}
11955		case "totalCount":
11956			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11957			if out.Values[i] == graphql.Null {
11958				invalids++
11959			}
11960		default:
11961			panic("unknown field " + strconv.Quote(field.Name))
11962		}
11963	}
11964	out.Dispatch()
11965	if invalids > 0 {
11966		return graphql.Null
11967	}
11968	return out
11969}
11970
11971var identityEdgeImplementors = []string{"IdentityEdge"}
11972
11973func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11974	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11975
11976	out := graphql.NewFieldSet(fields)
11977	var invalids uint32
11978	for i, field := range fields {
11979		switch field.Name {
11980		case "__typename":
11981			out.Values[i] = graphql.MarshalString("IdentityEdge")
11982		case "cursor":
11983			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11984			if out.Values[i] == graphql.Null {
11985				invalids++
11986			}
11987		case "node":
11988			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11989			if out.Values[i] == graphql.Null {
11990				invalids++
11991			}
11992		default:
11993			panic("unknown field " + strconv.Quote(field.Name))
11994		}
11995	}
11996	out.Dispatch()
11997	if invalids > 0 {
11998		return graphql.Null
11999	}
12000	return out
12001}
12002
12003var labelImplementors = []string{"Label"}
12004
12005func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
12006	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
12007
12008	out := graphql.NewFieldSet(fields)
12009	var invalids uint32
12010	for i, field := range fields {
12011		switch field.Name {
12012		case "__typename":
12013			out.Values[i] = graphql.MarshalString("Label")
12014		case "name":
12015			field := field
12016			out.Concurrently(i, func() (res graphql.Marshaler) {
12017				defer func() {
12018					if r := recover(); r != nil {
12019						ec.Error(ctx, ec.Recover(ctx, r))
12020					}
12021				}()
12022				res = ec._Label_name(ctx, field, obj)
12023				if res == graphql.Null {
12024					atomic.AddUint32(&invalids, 1)
12025				}
12026				return res
12027			})
12028		case "color":
12029			field := field
12030			out.Concurrently(i, func() (res graphql.Marshaler) {
12031				defer func() {
12032					if r := recover(); r != nil {
12033						ec.Error(ctx, ec.Recover(ctx, r))
12034					}
12035				}()
12036				res = ec._Label_color(ctx, field, obj)
12037				if res == graphql.Null {
12038					atomic.AddUint32(&invalids, 1)
12039				}
12040				return res
12041			})
12042		default:
12043			panic("unknown field " + strconv.Quote(field.Name))
12044		}
12045	}
12046	out.Dispatch()
12047	if invalids > 0 {
12048		return graphql.Null
12049	}
12050	return out
12051}
12052
12053var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12054
12055func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12056	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
12057
12058	out := graphql.NewFieldSet(fields)
12059	var invalids uint32
12060	for i, field := range fields {
12061		switch field.Name {
12062		case "__typename":
12063			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12064		case "id":
12065			field := field
12066			out.Concurrently(i, func() (res graphql.Marshaler) {
12067				defer func() {
12068					if r := recover(); r != nil {
12069						ec.Error(ctx, ec.Recover(ctx, r))
12070					}
12071				}()
12072				res = ec._LabelChangeOperation_id(ctx, field, obj)
12073				if res == graphql.Null {
12074					atomic.AddUint32(&invalids, 1)
12075				}
12076				return res
12077			})
12078		case "author":
12079			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
12080			if out.Values[i] == graphql.Null {
12081				atomic.AddUint32(&invalids, 1)
12082			}
12083		case "date":
12084			field := field
12085			out.Concurrently(i, func() (res graphql.Marshaler) {
12086				defer func() {
12087					if r := recover(); r != nil {
12088						ec.Error(ctx, ec.Recover(ctx, r))
12089					}
12090				}()
12091				res = ec._LabelChangeOperation_date(ctx, field, obj)
12092				if res == graphql.Null {
12093					atomic.AddUint32(&invalids, 1)
12094				}
12095				return res
12096			})
12097		case "added":
12098			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12099			if out.Values[i] == graphql.Null {
12100				atomic.AddUint32(&invalids, 1)
12101			}
12102		case "removed":
12103			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12104			if out.Values[i] == graphql.Null {
12105				atomic.AddUint32(&invalids, 1)
12106			}
12107		default:
12108			panic("unknown field " + strconv.Quote(field.Name))
12109		}
12110	}
12111	out.Dispatch()
12112	if invalids > 0 {
12113		return graphql.Null
12114	}
12115	return out
12116}
12117
12118var labelChangeResultImplementors = []string{"LabelChangeResult"}
12119
12120func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12121	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
12122
12123	out := graphql.NewFieldSet(fields)
12124	var invalids uint32
12125	for i, field := range fields {
12126		switch field.Name {
12127		case "__typename":
12128			out.Values[i] = graphql.MarshalString("LabelChangeResult")
12129		case "label":
12130			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12131			if out.Values[i] == graphql.Null {
12132				atomic.AddUint32(&invalids, 1)
12133			}
12134		case "status":
12135			field := field
12136			out.Concurrently(i, func() (res graphql.Marshaler) {
12137				defer func() {
12138					if r := recover(); r != nil {
12139						ec.Error(ctx, ec.Recover(ctx, r))
12140					}
12141				}()
12142				res = ec._LabelChangeResult_status(ctx, field, obj)
12143				if res == graphql.Null {
12144					atomic.AddUint32(&invalids, 1)
12145				}
12146				return res
12147			})
12148		default:
12149			panic("unknown field " + strconv.Quote(field.Name))
12150		}
12151	}
12152	out.Dispatch()
12153	if invalids > 0 {
12154		return graphql.Null
12155	}
12156	return out
12157}
12158
12159var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12160
12161func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12162	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
12163
12164	out := graphql.NewFieldSet(fields)
12165	var invalids uint32
12166	for i, field := range fields {
12167		switch field.Name {
12168		case "__typename":
12169			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12170		case "id":
12171			field := field
12172			out.Concurrently(i, func() (res graphql.Marshaler) {
12173				defer func() {
12174					if r := recover(); r != nil {
12175						ec.Error(ctx, ec.Recover(ctx, r))
12176					}
12177				}()
12178				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
12179				if res == graphql.Null {
12180					atomic.AddUint32(&invalids, 1)
12181				}
12182				return res
12183			})
12184		case "author":
12185			out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12186			if out.Values[i] == graphql.Null {
12187				atomic.AddUint32(&invalids, 1)
12188			}
12189		case "date":
12190			field := field
12191			out.Concurrently(i, func() (res graphql.Marshaler) {
12192				defer func() {
12193					if r := recover(); r != nil {
12194						ec.Error(ctx, ec.Recover(ctx, r))
12195					}
12196				}()
12197				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12198				if res == graphql.Null {
12199					atomic.AddUint32(&invalids, 1)
12200				}
12201				return res
12202			})
12203		case "added":
12204			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12205			if out.Values[i] == graphql.Null {
12206				atomic.AddUint32(&invalids, 1)
12207			}
12208		case "removed":
12209			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12210			if out.Values[i] == graphql.Null {
12211				atomic.AddUint32(&invalids, 1)
12212			}
12213		default:
12214			panic("unknown field " + strconv.Quote(field.Name))
12215		}
12216	}
12217	out.Dispatch()
12218	if invalids > 0 {
12219		return graphql.Null
12220	}
12221	return out
12222}
12223
12224var labelConnectionImplementors = []string{"LabelConnection"}
12225
12226func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12227	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12228
12229	out := graphql.NewFieldSet(fields)
12230	var invalids uint32
12231	for i, field := range fields {
12232		switch field.Name {
12233		case "__typename":
12234			out.Values[i] = graphql.MarshalString("LabelConnection")
12235		case "edges":
12236			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12237			if out.Values[i] == graphql.Null {
12238				invalids++
12239			}
12240		case "nodes":
12241			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12242			if out.Values[i] == graphql.Null {
12243				invalids++
12244			}
12245		case "pageInfo":
12246			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12247			if out.Values[i] == graphql.Null {
12248				invalids++
12249			}
12250		case "totalCount":
12251			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12252			if out.Values[i] == graphql.Null {
12253				invalids++
12254			}
12255		default:
12256			panic("unknown field " + strconv.Quote(field.Name))
12257		}
12258	}
12259	out.Dispatch()
12260	if invalids > 0 {
12261		return graphql.Null
12262	}
12263	return out
12264}
12265
12266var labelEdgeImplementors = []string{"LabelEdge"}
12267
12268func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12269	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12270
12271	out := graphql.NewFieldSet(fields)
12272	var invalids uint32
12273	for i, field := range fields {
12274		switch field.Name {
12275		case "__typename":
12276			out.Values[i] = graphql.MarshalString("LabelEdge")
12277		case "cursor":
12278			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12279			if out.Values[i] == graphql.Null {
12280				invalids++
12281			}
12282		case "node":
12283			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12284			if out.Values[i] == graphql.Null {
12285				invalids++
12286			}
12287		default:
12288			panic("unknown field " + strconv.Quote(field.Name))
12289		}
12290	}
12291	out.Dispatch()
12292	if invalids > 0 {
12293		return graphql.Null
12294	}
12295	return out
12296}
12297
12298var mutationImplementors = []string{"Mutation"}
12299
12300func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12301	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12302
12303	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12304		Object: "Mutation",
12305	})
12306
12307	out := graphql.NewFieldSet(fields)
12308	var invalids uint32
12309	for i, field := range fields {
12310		switch field.Name {
12311		case "__typename":
12312			out.Values[i] = graphql.MarshalString("Mutation")
12313		case "newBug":
12314			out.Values[i] = ec._Mutation_newBug(ctx, field)
12315			if out.Values[i] == graphql.Null {
12316				invalids++
12317			}
12318		case "addComment":
12319			out.Values[i] = ec._Mutation_addComment(ctx, field)
12320			if out.Values[i] == graphql.Null {
12321				invalids++
12322			}
12323		case "changeLabels":
12324			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12325			if out.Values[i] == graphql.Null {
12326				invalids++
12327			}
12328		case "openBug":
12329			out.Values[i] = ec._Mutation_openBug(ctx, field)
12330			if out.Values[i] == graphql.Null {
12331				invalids++
12332			}
12333		case "closeBug":
12334			out.Values[i] = ec._Mutation_closeBug(ctx, field)
12335			if out.Values[i] == graphql.Null {
12336				invalids++
12337			}
12338		case "setTitle":
12339			out.Values[i] = ec._Mutation_setTitle(ctx, field)
12340			if out.Values[i] == graphql.Null {
12341				invalids++
12342			}
12343		case "commit":
12344			out.Values[i] = ec._Mutation_commit(ctx, field)
12345			if out.Values[i] == graphql.Null {
12346				invalids++
12347			}
12348		case "commitAsNeeded":
12349			out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12350			if out.Values[i] == graphql.Null {
12351				invalids++
12352			}
12353		default:
12354			panic("unknown field " + strconv.Quote(field.Name))
12355		}
12356	}
12357	out.Dispatch()
12358	if invalids > 0 {
12359		return graphql.Null
12360	}
12361	return out
12362}
12363
12364var newBugPayloadImplementors = []string{"NewBugPayload"}
12365
12366func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12367	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12368
12369	out := graphql.NewFieldSet(fields)
12370	var invalids uint32
12371	for i, field := range fields {
12372		switch field.Name {
12373		case "__typename":
12374			out.Values[i] = graphql.MarshalString("NewBugPayload")
12375		case "clientMutationId":
12376			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12377		case "bug":
12378			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12379			if out.Values[i] == graphql.Null {
12380				invalids++
12381			}
12382		case "operation":
12383			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12384			if out.Values[i] == graphql.Null {
12385				invalids++
12386			}
12387		default:
12388			panic("unknown field " + strconv.Quote(field.Name))
12389		}
12390	}
12391	out.Dispatch()
12392	if invalids > 0 {
12393		return graphql.Null
12394	}
12395	return out
12396}
12397
12398var openBugPayloadImplementors = []string{"OpenBugPayload"}
12399
12400func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12401	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12402
12403	out := graphql.NewFieldSet(fields)
12404	var invalids uint32
12405	for i, field := range fields {
12406		switch field.Name {
12407		case "__typename":
12408			out.Values[i] = graphql.MarshalString("OpenBugPayload")
12409		case "clientMutationId":
12410			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12411		case "bug":
12412			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12413			if out.Values[i] == graphql.Null {
12414				invalids++
12415			}
12416		case "operation":
12417			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12418			if out.Values[i] == graphql.Null {
12419				invalids++
12420			}
12421		default:
12422			panic("unknown field " + strconv.Quote(field.Name))
12423		}
12424	}
12425	out.Dispatch()
12426	if invalids > 0 {
12427		return graphql.Null
12428	}
12429	return out
12430}
12431
12432var operationConnectionImplementors = []string{"OperationConnection"}
12433
12434func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12435	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12436
12437	out := graphql.NewFieldSet(fields)
12438	var invalids uint32
12439	for i, field := range fields {
12440		switch field.Name {
12441		case "__typename":
12442			out.Values[i] = graphql.MarshalString("OperationConnection")
12443		case "edges":
12444			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12445			if out.Values[i] == graphql.Null {
12446				invalids++
12447			}
12448		case "nodes":
12449			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12450			if out.Values[i] == graphql.Null {
12451				invalids++
12452			}
12453		case "pageInfo":
12454			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12455			if out.Values[i] == graphql.Null {
12456				invalids++
12457			}
12458		case "totalCount":
12459			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12460			if out.Values[i] == graphql.Null {
12461				invalids++
12462			}
12463		default:
12464			panic("unknown field " + strconv.Quote(field.Name))
12465		}
12466	}
12467	out.Dispatch()
12468	if invalids > 0 {
12469		return graphql.Null
12470	}
12471	return out
12472}
12473
12474var operationEdgeImplementors = []string{"OperationEdge"}
12475
12476func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12477	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12478
12479	out := graphql.NewFieldSet(fields)
12480	var invalids uint32
12481	for i, field := range fields {
12482		switch field.Name {
12483		case "__typename":
12484			out.Values[i] = graphql.MarshalString("OperationEdge")
12485		case "cursor":
12486			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12487			if out.Values[i] == graphql.Null {
12488				invalids++
12489			}
12490		case "node":
12491			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12492			if out.Values[i] == graphql.Null {
12493				invalids++
12494			}
12495		default:
12496			panic("unknown field " + strconv.Quote(field.Name))
12497		}
12498	}
12499	out.Dispatch()
12500	if invalids > 0 {
12501		return graphql.Null
12502	}
12503	return out
12504}
12505
12506var pageInfoImplementors = []string{"PageInfo"}
12507
12508func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12509	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12510
12511	out := graphql.NewFieldSet(fields)
12512	var invalids uint32
12513	for i, field := range fields {
12514		switch field.Name {
12515		case "__typename":
12516			out.Values[i] = graphql.MarshalString("PageInfo")
12517		case "hasNextPage":
12518			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12519			if out.Values[i] == graphql.Null {
12520				invalids++
12521			}
12522		case "hasPreviousPage":
12523			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12524			if out.Values[i] == graphql.Null {
12525				invalids++
12526			}
12527		case "startCursor":
12528			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12529			if out.Values[i] == graphql.Null {
12530				invalids++
12531			}
12532		case "endCursor":
12533			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12534			if out.Values[i] == graphql.Null {
12535				invalids++
12536			}
12537		default:
12538			panic("unknown field " + strconv.Quote(field.Name))
12539		}
12540	}
12541	out.Dispatch()
12542	if invalids > 0 {
12543		return graphql.Null
12544	}
12545	return out
12546}
12547
12548var queryImplementors = []string{"Query"}
12549
12550func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12551	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12552
12553	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12554		Object: "Query",
12555	})
12556
12557	out := graphql.NewFieldSet(fields)
12558	var invalids uint32
12559	for i, field := range fields {
12560		switch field.Name {
12561		case "__typename":
12562			out.Values[i] = graphql.MarshalString("Query")
12563		case "defaultRepository":
12564			field := field
12565			out.Concurrently(i, func() (res graphql.Marshaler) {
12566				defer func() {
12567					if r := recover(); r != nil {
12568						ec.Error(ctx, ec.Recover(ctx, r))
12569					}
12570				}()
12571				res = ec._Query_defaultRepository(ctx, field)
12572				return res
12573			})
12574		case "repository":
12575			field := field
12576			out.Concurrently(i, func() (res graphql.Marshaler) {
12577				defer func() {
12578					if r := recover(); r != nil {
12579						ec.Error(ctx, ec.Recover(ctx, r))
12580					}
12581				}()
12582				res = ec._Query_repository(ctx, field)
12583				return res
12584			})
12585		case "__type":
12586			out.Values[i] = ec._Query___type(ctx, field)
12587		case "__schema":
12588			out.Values[i] = ec._Query___schema(ctx, field)
12589		default:
12590			panic("unknown field " + strconv.Quote(field.Name))
12591		}
12592	}
12593	out.Dispatch()
12594	if invalids > 0 {
12595		return graphql.Null
12596	}
12597	return out
12598}
12599
12600var repositoryImplementors = []string{"Repository"}
12601
12602func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12603	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12604
12605	out := graphql.NewFieldSet(fields)
12606	var invalids uint32
12607	for i, field := range fields {
12608		switch field.Name {
12609		case "__typename":
12610			out.Values[i] = graphql.MarshalString("Repository")
12611		case "allBugs":
12612			field := field
12613			out.Concurrently(i, func() (res graphql.Marshaler) {
12614				defer func() {
12615					if r := recover(); r != nil {
12616						ec.Error(ctx, ec.Recover(ctx, r))
12617					}
12618				}()
12619				res = ec._Repository_allBugs(ctx, field, obj)
12620				if res == graphql.Null {
12621					atomic.AddUint32(&invalids, 1)
12622				}
12623				return res
12624			})
12625		case "bug":
12626			field := field
12627			out.Concurrently(i, func() (res graphql.Marshaler) {
12628				defer func() {
12629					if r := recover(); r != nil {
12630						ec.Error(ctx, ec.Recover(ctx, r))
12631					}
12632				}()
12633				res = ec._Repository_bug(ctx, field, obj)
12634				return res
12635			})
12636		case "allIdentities":
12637			field := field
12638			out.Concurrently(i, func() (res graphql.Marshaler) {
12639				defer func() {
12640					if r := recover(); r != nil {
12641						ec.Error(ctx, ec.Recover(ctx, r))
12642					}
12643				}()
12644				res = ec._Repository_allIdentities(ctx, field, obj)
12645				if res == graphql.Null {
12646					atomic.AddUint32(&invalids, 1)
12647				}
12648				return res
12649			})
12650		case "identity":
12651			field := field
12652			out.Concurrently(i, func() (res graphql.Marshaler) {
12653				defer func() {
12654					if r := recover(); r != nil {
12655						ec.Error(ctx, ec.Recover(ctx, r))
12656					}
12657				}()
12658				res = ec._Repository_identity(ctx, field, obj)
12659				return res
12660			})
12661		case "userIdentity":
12662			field := field
12663			out.Concurrently(i, func() (res graphql.Marshaler) {
12664				defer func() {
12665					if r := recover(); r != nil {
12666						ec.Error(ctx, ec.Recover(ctx, r))
12667					}
12668				}()
12669				res = ec._Repository_userIdentity(ctx, field, obj)
12670				return res
12671			})
12672		case "validLabels":
12673			field := field
12674			out.Concurrently(i, func() (res graphql.Marshaler) {
12675				defer func() {
12676					if r := recover(); r != nil {
12677						ec.Error(ctx, ec.Recover(ctx, r))
12678					}
12679				}()
12680				res = ec._Repository_validLabels(ctx, field, obj)
12681				if res == graphql.Null {
12682					atomic.AddUint32(&invalids, 1)
12683				}
12684				return res
12685			})
12686		default:
12687			panic("unknown field " + strconv.Quote(field.Name))
12688		}
12689	}
12690	out.Dispatch()
12691	if invalids > 0 {
12692		return graphql.Null
12693	}
12694	return out
12695}
12696
12697var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12698
12699func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12700	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12701
12702	out := graphql.NewFieldSet(fields)
12703	var invalids uint32
12704	for i, field := range fields {
12705		switch field.Name {
12706		case "__typename":
12707			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12708		case "id":
12709			field := field
12710			out.Concurrently(i, func() (res graphql.Marshaler) {
12711				defer func() {
12712					if r := recover(); r != nil {
12713						ec.Error(ctx, ec.Recover(ctx, r))
12714					}
12715				}()
12716				res = ec._SetStatusOperation_id(ctx, field, obj)
12717				if res == graphql.Null {
12718					atomic.AddUint32(&invalids, 1)
12719				}
12720				return res
12721			})
12722		case "author":
12723			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
12724			if out.Values[i] == graphql.Null {
12725				atomic.AddUint32(&invalids, 1)
12726			}
12727		case "date":
12728			field := field
12729			out.Concurrently(i, func() (res graphql.Marshaler) {
12730				defer func() {
12731					if r := recover(); r != nil {
12732						ec.Error(ctx, ec.Recover(ctx, r))
12733					}
12734				}()
12735				res = ec._SetStatusOperation_date(ctx, field, obj)
12736				if res == graphql.Null {
12737					atomic.AddUint32(&invalids, 1)
12738				}
12739				return res
12740			})
12741		case "status":
12742			field := field
12743			out.Concurrently(i, func() (res graphql.Marshaler) {
12744				defer func() {
12745					if r := recover(); r != nil {
12746						ec.Error(ctx, ec.Recover(ctx, r))
12747					}
12748				}()
12749				res = ec._SetStatusOperation_status(ctx, field, obj)
12750				if res == graphql.Null {
12751					atomic.AddUint32(&invalids, 1)
12752				}
12753				return res
12754			})
12755		default:
12756			panic("unknown field " + strconv.Quote(field.Name))
12757		}
12758	}
12759	out.Dispatch()
12760	if invalids > 0 {
12761		return graphql.Null
12762	}
12763	return out
12764}
12765
12766var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12767
12768func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12769	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12770
12771	out := graphql.NewFieldSet(fields)
12772	var invalids uint32
12773	for i, field := range fields {
12774		switch field.Name {
12775		case "__typename":
12776			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12777		case "id":
12778			field := field
12779			out.Concurrently(i, func() (res graphql.Marshaler) {
12780				defer func() {
12781					if r := recover(); r != nil {
12782						ec.Error(ctx, ec.Recover(ctx, r))
12783					}
12784				}()
12785				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12786				if res == graphql.Null {
12787					atomic.AddUint32(&invalids, 1)
12788				}
12789				return res
12790			})
12791		case "author":
12792			out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
12793			if out.Values[i] == graphql.Null {
12794				atomic.AddUint32(&invalids, 1)
12795			}
12796		case "date":
12797			field := field
12798			out.Concurrently(i, func() (res graphql.Marshaler) {
12799				defer func() {
12800					if r := recover(); r != nil {
12801						ec.Error(ctx, ec.Recover(ctx, r))
12802					}
12803				}()
12804				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12805				if res == graphql.Null {
12806					atomic.AddUint32(&invalids, 1)
12807				}
12808				return res
12809			})
12810		case "status":
12811			field := field
12812			out.Concurrently(i, func() (res graphql.Marshaler) {
12813				defer func() {
12814					if r := recover(); r != nil {
12815						ec.Error(ctx, ec.Recover(ctx, r))
12816					}
12817				}()
12818				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12819				if res == graphql.Null {
12820					atomic.AddUint32(&invalids, 1)
12821				}
12822				return res
12823			})
12824		default:
12825			panic("unknown field " + strconv.Quote(field.Name))
12826		}
12827	}
12828	out.Dispatch()
12829	if invalids > 0 {
12830		return graphql.Null
12831	}
12832	return out
12833}
12834
12835var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12836
12837func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12838	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12839
12840	out := graphql.NewFieldSet(fields)
12841	var invalids uint32
12842	for i, field := range fields {
12843		switch field.Name {
12844		case "__typename":
12845			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12846		case "id":
12847			field := field
12848			out.Concurrently(i, func() (res graphql.Marshaler) {
12849				defer func() {
12850					if r := recover(); r != nil {
12851						ec.Error(ctx, ec.Recover(ctx, r))
12852					}
12853				}()
12854				res = ec._SetTitleOperation_id(ctx, field, obj)
12855				if res == graphql.Null {
12856					atomic.AddUint32(&invalids, 1)
12857				}
12858				return res
12859			})
12860		case "author":
12861			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
12862			if out.Values[i] == graphql.Null {
12863				atomic.AddUint32(&invalids, 1)
12864			}
12865		case "date":
12866			field := field
12867			out.Concurrently(i, func() (res graphql.Marshaler) {
12868				defer func() {
12869					if r := recover(); r != nil {
12870						ec.Error(ctx, ec.Recover(ctx, r))
12871					}
12872				}()
12873				res = ec._SetTitleOperation_date(ctx, field, obj)
12874				if res == graphql.Null {
12875					atomic.AddUint32(&invalids, 1)
12876				}
12877				return res
12878			})
12879		case "title":
12880			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12881			if out.Values[i] == graphql.Null {
12882				atomic.AddUint32(&invalids, 1)
12883			}
12884		case "was":
12885			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12886			if out.Values[i] == graphql.Null {
12887				atomic.AddUint32(&invalids, 1)
12888			}
12889		default:
12890			panic("unknown field " + strconv.Quote(field.Name))
12891		}
12892	}
12893	out.Dispatch()
12894	if invalids > 0 {
12895		return graphql.Null
12896	}
12897	return out
12898}
12899
12900var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12901
12902func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12903	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12904
12905	out := graphql.NewFieldSet(fields)
12906	var invalids uint32
12907	for i, field := range fields {
12908		switch field.Name {
12909		case "__typename":
12910			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12911		case "clientMutationId":
12912			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12913		case "bug":
12914			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12915			if out.Values[i] == graphql.Null {
12916				invalids++
12917			}
12918		case "operation":
12919			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12920			if out.Values[i] == graphql.Null {
12921				invalids++
12922			}
12923		default:
12924			panic("unknown field " + strconv.Quote(field.Name))
12925		}
12926	}
12927	out.Dispatch()
12928	if invalids > 0 {
12929		return graphql.Null
12930	}
12931	return out
12932}
12933
12934var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12935
12936func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12937	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12938
12939	out := graphql.NewFieldSet(fields)
12940	var invalids uint32
12941	for i, field := range fields {
12942		switch field.Name {
12943		case "__typename":
12944			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12945		case "id":
12946			field := field
12947			out.Concurrently(i, func() (res graphql.Marshaler) {
12948				defer func() {
12949					if r := recover(); r != nil {
12950						ec.Error(ctx, ec.Recover(ctx, r))
12951					}
12952				}()
12953				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12954				if res == graphql.Null {
12955					atomic.AddUint32(&invalids, 1)
12956				}
12957				return res
12958			})
12959		case "author":
12960			out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
12961			if out.Values[i] == graphql.Null {
12962				atomic.AddUint32(&invalids, 1)
12963			}
12964		case "date":
12965			field := field
12966			out.Concurrently(i, func() (res graphql.Marshaler) {
12967				defer func() {
12968					if r := recover(); r != nil {
12969						ec.Error(ctx, ec.Recover(ctx, r))
12970					}
12971				}()
12972				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12973				if res == graphql.Null {
12974					atomic.AddUint32(&invalids, 1)
12975				}
12976				return res
12977			})
12978		case "title":
12979			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12980			if out.Values[i] == graphql.Null {
12981				atomic.AddUint32(&invalids, 1)
12982			}
12983		case "was":
12984			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12985			if out.Values[i] == graphql.Null {
12986				atomic.AddUint32(&invalids, 1)
12987			}
12988		default:
12989			panic("unknown field " + strconv.Quote(field.Name))
12990		}
12991	}
12992	out.Dispatch()
12993	if invalids > 0 {
12994		return graphql.Null
12995	}
12996	return out
12997}
12998
12999var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
13000
13001func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
13002	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
13003
13004	out := graphql.NewFieldSet(fields)
13005	var invalids uint32
13006	for i, field := range fields {
13007		switch field.Name {
13008		case "__typename":
13009			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
13010		case "edges":
13011			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
13012			if out.Values[i] == graphql.Null {
13013				invalids++
13014			}
13015		case "nodes":
13016			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
13017			if out.Values[i] == graphql.Null {
13018				invalids++
13019			}
13020		case "pageInfo":
13021			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
13022			if out.Values[i] == graphql.Null {
13023				invalids++
13024			}
13025		case "totalCount":
13026			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
13027			if out.Values[i] == graphql.Null {
13028				invalids++
13029			}
13030		default:
13031			panic("unknown field " + strconv.Quote(field.Name))
13032		}
13033	}
13034	out.Dispatch()
13035	if invalids > 0 {
13036		return graphql.Null
13037	}
13038	return out
13039}
13040
13041var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
13042
13043func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
13044	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
13045
13046	out := graphql.NewFieldSet(fields)
13047	var invalids uint32
13048	for i, field := range fields {
13049		switch field.Name {
13050		case "__typename":
13051			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
13052		case "cursor":
13053			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
13054			if out.Values[i] == graphql.Null {
13055				invalids++
13056			}
13057		case "node":
13058			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
13059			if out.Values[i] == graphql.Null {
13060				invalids++
13061			}
13062		default:
13063			panic("unknown field " + strconv.Quote(field.Name))
13064		}
13065	}
13066	out.Dispatch()
13067	if invalids > 0 {
13068		return graphql.Null
13069	}
13070	return out
13071}
13072
13073var __DirectiveImplementors = []string{"__Directive"}
13074
13075func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
13076	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
13077
13078	out := graphql.NewFieldSet(fields)
13079	var invalids uint32
13080	for i, field := range fields {
13081		switch field.Name {
13082		case "__typename":
13083			out.Values[i] = graphql.MarshalString("__Directive")
13084		case "name":
13085			out.Values[i] = ec.___Directive_name(ctx, field, obj)
13086			if out.Values[i] == graphql.Null {
13087				invalids++
13088			}
13089		case "description":
13090			out.Values[i] = ec.___Directive_description(ctx, field, obj)
13091		case "locations":
13092			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
13093			if out.Values[i] == graphql.Null {
13094				invalids++
13095			}
13096		case "args":
13097			out.Values[i] = ec.___Directive_args(ctx, field, obj)
13098			if out.Values[i] == graphql.Null {
13099				invalids++
13100			}
13101		default:
13102			panic("unknown field " + strconv.Quote(field.Name))
13103		}
13104	}
13105	out.Dispatch()
13106	if invalids > 0 {
13107		return graphql.Null
13108	}
13109	return out
13110}
13111
13112var __EnumValueImplementors = []string{"__EnumValue"}
13113
13114func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
13115	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
13116
13117	out := graphql.NewFieldSet(fields)
13118	var invalids uint32
13119	for i, field := range fields {
13120		switch field.Name {
13121		case "__typename":
13122			out.Values[i] = graphql.MarshalString("__EnumValue")
13123		case "name":
13124			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
13125			if out.Values[i] == graphql.Null {
13126				invalids++
13127			}
13128		case "description":
13129			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
13130		case "isDeprecated":
13131			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
13132			if out.Values[i] == graphql.Null {
13133				invalids++
13134			}
13135		case "deprecationReason":
13136			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
13137		default:
13138			panic("unknown field " + strconv.Quote(field.Name))
13139		}
13140	}
13141	out.Dispatch()
13142	if invalids > 0 {
13143		return graphql.Null
13144	}
13145	return out
13146}
13147
13148var __FieldImplementors = []string{"__Field"}
13149
13150func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
13151	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
13152
13153	out := graphql.NewFieldSet(fields)
13154	var invalids uint32
13155	for i, field := range fields {
13156		switch field.Name {
13157		case "__typename":
13158			out.Values[i] = graphql.MarshalString("__Field")
13159		case "name":
13160			out.Values[i] = ec.___Field_name(ctx, field, obj)
13161			if out.Values[i] == graphql.Null {
13162				invalids++
13163			}
13164		case "description":
13165			out.Values[i] = ec.___Field_description(ctx, field, obj)
13166		case "args":
13167			out.Values[i] = ec.___Field_args(ctx, field, obj)
13168			if out.Values[i] == graphql.Null {
13169				invalids++
13170			}
13171		case "type":
13172			out.Values[i] = ec.___Field_type(ctx, field, obj)
13173			if out.Values[i] == graphql.Null {
13174				invalids++
13175			}
13176		case "isDeprecated":
13177			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13178			if out.Values[i] == graphql.Null {
13179				invalids++
13180			}
13181		case "deprecationReason":
13182			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13183		default:
13184			panic("unknown field " + strconv.Quote(field.Name))
13185		}
13186	}
13187	out.Dispatch()
13188	if invalids > 0 {
13189		return graphql.Null
13190	}
13191	return out
13192}
13193
13194var __InputValueImplementors = []string{"__InputValue"}
13195
13196func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13197	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13198
13199	out := graphql.NewFieldSet(fields)
13200	var invalids uint32
13201	for i, field := range fields {
13202		switch field.Name {
13203		case "__typename":
13204			out.Values[i] = graphql.MarshalString("__InputValue")
13205		case "name":
13206			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13207			if out.Values[i] == graphql.Null {
13208				invalids++
13209			}
13210		case "description":
13211			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13212		case "type":
13213			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13214			if out.Values[i] == graphql.Null {
13215				invalids++
13216			}
13217		case "defaultValue":
13218			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13219		default:
13220			panic("unknown field " + strconv.Quote(field.Name))
13221		}
13222	}
13223	out.Dispatch()
13224	if invalids > 0 {
13225		return graphql.Null
13226	}
13227	return out
13228}
13229
13230var __SchemaImplementors = []string{"__Schema"}
13231
13232func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13233	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13234
13235	out := graphql.NewFieldSet(fields)
13236	var invalids uint32
13237	for i, field := range fields {
13238		switch field.Name {
13239		case "__typename":
13240			out.Values[i] = graphql.MarshalString("__Schema")
13241		case "types":
13242			out.Values[i] = ec.___Schema_types(ctx, field, obj)
13243			if out.Values[i] == graphql.Null {
13244				invalids++
13245			}
13246		case "queryType":
13247			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13248			if out.Values[i] == graphql.Null {
13249				invalids++
13250			}
13251		case "mutationType":
13252			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13253		case "subscriptionType":
13254			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13255		case "directives":
13256			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13257			if out.Values[i] == graphql.Null {
13258				invalids++
13259			}
13260		default:
13261			panic("unknown field " + strconv.Quote(field.Name))
13262		}
13263	}
13264	out.Dispatch()
13265	if invalids > 0 {
13266		return graphql.Null
13267	}
13268	return out
13269}
13270
13271var __TypeImplementors = []string{"__Type"}
13272
13273func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13274	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13275
13276	out := graphql.NewFieldSet(fields)
13277	var invalids uint32
13278	for i, field := range fields {
13279		switch field.Name {
13280		case "__typename":
13281			out.Values[i] = graphql.MarshalString("__Type")
13282		case "kind":
13283			out.Values[i] = ec.___Type_kind(ctx, field, obj)
13284			if out.Values[i] == graphql.Null {
13285				invalids++
13286			}
13287		case "name":
13288			out.Values[i] = ec.___Type_name(ctx, field, obj)
13289		case "description":
13290			out.Values[i] = ec.___Type_description(ctx, field, obj)
13291		case "fields":
13292			out.Values[i] = ec.___Type_fields(ctx, field, obj)
13293		case "interfaces":
13294			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13295		case "possibleTypes":
13296			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13297		case "enumValues":
13298			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13299		case "inputFields":
13300			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13301		case "ofType":
13302			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13303		default:
13304			panic("unknown field " + strconv.Quote(field.Name))
13305		}
13306	}
13307	out.Dispatch()
13308	if invalids > 0 {
13309		return graphql.Null
13310	}
13311	return out
13312}
13313
13314// endregion **************************** object.gotpl ****************************
13315
13316// region    ***************************** type.gotpl *****************************
13317
13318func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13319	return ec.unmarshalInputAddCommentInput(ctx, v)
13320}
13321
13322func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13323	return ec._AddCommentOperation(ctx, sel, &v)
13324}
13325
13326func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13327	if v == nil {
13328		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13329			ec.Errorf(ctx, "must not be null")
13330		}
13331		return graphql.Null
13332	}
13333	return ec._AddCommentOperation(ctx, sel, v)
13334}
13335
13336func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13337	return ec._AddCommentPayload(ctx, sel, &v)
13338}
13339
13340func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13341	if v == nil {
13342		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13343			ec.Errorf(ctx, "must not be null")
13344		}
13345		return graphql.Null
13346	}
13347	return ec._AddCommentPayload(ctx, sel, v)
13348}
13349
13350func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13351	return graphql.UnmarshalBoolean(v)
13352}
13353
13354func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13355	res := graphql.MarshalBoolean(v)
13356	if res == graphql.Null {
13357		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13358			ec.Errorf(ctx, "must not be null")
13359		}
13360	}
13361	return res
13362}
13363
13364func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
13365	return ec._Bug(ctx, sel, &v)
13366}
13367
13368func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshotᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
13369	ret := make(graphql.Array, len(v))
13370	var wg sync.WaitGroup
13371	isLen1 := len(v) == 1
13372	if !isLen1 {
13373		wg.Add(len(v))
13374	}
13375	for i := range v {
13376		i := i
13377		fc := &graphql.FieldContext{
13378			Index:  &i,
13379			Result: &v[i],
13380		}
13381		ctx := graphql.WithFieldContext(ctx, fc)
13382		f := func(i int) {
13383			defer func() {
13384				if r := recover(); r != nil {
13385					ec.Error(ctx, ec.Recover(ctx, r))
13386					ret = nil
13387				}
13388			}()
13389			if !isLen1 {
13390				defer wg.Done()
13391			}
13392			ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
13393		}
13394		if isLen1 {
13395			f(i)
13396		} else {
13397			go f(i)
13398		}
13399
13400	}
13401	wg.Wait()
13402	return ret
13403}
13404
13405func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
13406	if v == nil {
13407		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13408			ec.Errorf(ctx, "must not be null")
13409		}
13410		return graphql.Null
13411	}
13412	return ec._Bug(ctx, sel, v)
13413}
13414
13415func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13416	return ec._BugConnection(ctx, sel, &v)
13417}
13418
13419func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13420	if v == nil {
13421		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13422			ec.Errorf(ctx, "must not be null")
13423		}
13424		return graphql.Null
13425	}
13426	return ec._BugConnection(ctx, sel, v)
13427}
13428
13429func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13430	return ec._BugEdge(ctx, sel, &v)
13431}
13432
13433func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13434	ret := make(graphql.Array, len(v))
13435	var wg sync.WaitGroup
13436	isLen1 := len(v) == 1
13437	if !isLen1 {
13438		wg.Add(len(v))
13439	}
13440	for i := range v {
13441		i := i
13442		fc := &graphql.FieldContext{
13443			Index:  &i,
13444			Result: &v[i],
13445		}
13446		ctx := graphql.WithFieldContext(ctx, fc)
13447		f := func(i int) {
13448			defer func() {
13449				if r := recover(); r != nil {
13450					ec.Error(ctx, ec.Recover(ctx, r))
13451					ret = nil
13452				}
13453			}()
13454			if !isLen1 {
13455				defer wg.Done()
13456			}
13457			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13458		}
13459		if isLen1 {
13460			f(i)
13461		} else {
13462			go f(i)
13463		}
13464
13465	}
13466	wg.Wait()
13467	return ret
13468}
13469
13470func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13471	if v == nil {
13472		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13473			ec.Errorf(ctx, "must not be null")
13474		}
13475		return graphql.Null
13476	}
13477	return ec._BugEdge(ctx, sel, v)
13478}
13479
13480func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13481	return ec._ChangeLabelPayload(ctx, sel, &v)
13482}
13483
13484func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13485	if v == nil {
13486		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13487			ec.Errorf(ctx, "must not be null")
13488		}
13489		return graphql.Null
13490	}
13491	return ec._ChangeLabelPayload(ctx, sel, v)
13492}
13493
13494func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13495	return ec.unmarshalInputCloseBugInput(ctx, v)
13496}
13497
13498func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13499	return ec._CloseBugPayload(ctx, sel, &v)
13500}
13501
13502func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13503	if v == nil {
13504		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13505			ec.Errorf(ctx, "must not be null")
13506		}
13507		return graphql.Null
13508	}
13509	return ec._CloseBugPayload(ctx, sel, v)
13510}
13511
13512func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13513	return ec._Color(ctx, sel, &v)
13514}
13515
13516func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13517	if v == nil {
13518		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13519			ec.Errorf(ctx, "must not be null")
13520		}
13521		return graphql.Null
13522	}
13523	return ec._Color(ctx, sel, v)
13524}
13525
13526func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13527	return ec._Comment(ctx, sel, &v)
13528}
13529
13530func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13531	ret := make(graphql.Array, len(v))
13532	var wg sync.WaitGroup
13533	isLen1 := len(v) == 1
13534	if !isLen1 {
13535		wg.Add(len(v))
13536	}
13537	for i := range v {
13538		i := i
13539		fc := &graphql.FieldContext{
13540			Index:  &i,
13541			Result: &v[i],
13542		}
13543		ctx := graphql.WithFieldContext(ctx, fc)
13544		f := func(i int) {
13545			defer func() {
13546				if r := recover(); r != nil {
13547					ec.Error(ctx, ec.Recover(ctx, r))
13548					ret = nil
13549				}
13550			}()
13551			if !isLen1 {
13552				defer wg.Done()
13553			}
13554			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13555		}
13556		if isLen1 {
13557			f(i)
13558		} else {
13559			go f(i)
13560		}
13561
13562	}
13563	wg.Wait()
13564	return ret
13565}
13566
13567func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13568	if v == nil {
13569		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13570			ec.Errorf(ctx, "must not be null")
13571		}
13572		return graphql.Null
13573	}
13574	return ec._Comment(ctx, sel, v)
13575}
13576
13577func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13578	return ec._CommentConnection(ctx, sel, &v)
13579}
13580
13581func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13582	if v == nil {
13583		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13584			ec.Errorf(ctx, "must not be null")
13585		}
13586		return graphql.Null
13587	}
13588	return ec._CommentConnection(ctx, sel, v)
13589}
13590
13591func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13592	return ec._CommentEdge(ctx, sel, &v)
13593}
13594
13595func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13596	ret := make(graphql.Array, len(v))
13597	var wg sync.WaitGroup
13598	isLen1 := len(v) == 1
13599	if !isLen1 {
13600		wg.Add(len(v))
13601	}
13602	for i := range v {
13603		i := i
13604		fc := &graphql.FieldContext{
13605			Index:  &i,
13606			Result: &v[i],
13607		}
13608		ctx := graphql.WithFieldContext(ctx, fc)
13609		f := func(i int) {
13610			defer func() {
13611				if r := recover(); r != nil {
13612					ec.Error(ctx, ec.Recover(ctx, r))
13613					ret = nil
13614				}
13615			}()
13616			if !isLen1 {
13617				defer wg.Done()
13618			}
13619			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13620		}
13621		if isLen1 {
13622			f(i)
13623		} else {
13624			go f(i)
13625		}
13626
13627	}
13628	wg.Wait()
13629	return ret
13630}
13631
13632func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13633	if v == nil {
13634		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13635			ec.Errorf(ctx, "must not be null")
13636		}
13637		return graphql.Null
13638	}
13639	return ec._CommentEdge(ctx, sel, v)
13640}
13641
13642func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13643	return ec._CommentHistoryStep(ctx, sel, &v)
13644}
13645
13646func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13647	ret := make(graphql.Array, len(v))
13648	var wg sync.WaitGroup
13649	isLen1 := len(v) == 1
13650	if !isLen1 {
13651		wg.Add(len(v))
13652	}
13653	for i := range v {
13654		i := i
13655		fc := &graphql.FieldContext{
13656			Index:  &i,
13657			Result: &v[i],
13658		}
13659		ctx := graphql.WithFieldContext(ctx, fc)
13660		f := func(i int) {
13661			defer func() {
13662				if r := recover(); r != nil {
13663					ec.Error(ctx, ec.Recover(ctx, r))
13664					ret = nil
13665				}
13666			}()
13667			if !isLen1 {
13668				defer wg.Done()
13669			}
13670			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13671		}
13672		if isLen1 {
13673			f(i)
13674		} else {
13675			go f(i)
13676		}
13677
13678	}
13679	wg.Wait()
13680	return ret
13681}
13682
13683func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13684	return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13685}
13686
13687func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13688	return ec._CommitAsNeededPayload(ctx, sel, &v)
13689}
13690
13691func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13692	if v == nil {
13693		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13694			ec.Errorf(ctx, "must not be null")
13695		}
13696		return graphql.Null
13697	}
13698	return ec._CommitAsNeededPayload(ctx, sel, v)
13699}
13700
13701func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13702	return ec.unmarshalInputCommitInput(ctx, v)
13703}
13704
13705func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13706	return ec._CommitPayload(ctx, sel, &v)
13707}
13708
13709func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13710	if v == nil {
13711		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13712			ec.Errorf(ctx, "must not be null")
13713		}
13714		return graphql.Null
13715	}
13716	return ec._CommitPayload(ctx, sel, v)
13717}
13718
13719func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13720	return ec._CreateOperation(ctx, sel, &v)
13721}
13722
13723func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13724	if v == nil {
13725		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13726			ec.Errorf(ctx, "must not be null")
13727		}
13728		return graphql.Null
13729	}
13730	return ec._CreateOperation(ctx, sel, v)
13731}
13732
13733func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13734	var res git.Hash
13735	return res, res.UnmarshalGQL(v)
13736}
13737
13738func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13739	return v
13740}
13741
13742func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13743	var vSlice []interface{}
13744	if v != nil {
13745		if tmp1, ok := v.([]interface{}); ok {
13746			vSlice = tmp1
13747		} else {
13748			vSlice = []interface{}{v}
13749		}
13750	}
13751	var err error
13752	res := make([]git.Hash, len(vSlice))
13753	for i := range vSlice {
13754		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13755		if err != nil {
13756			return nil, err
13757		}
13758	}
13759	return res, nil
13760}
13761
13762func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13763	ret := make(graphql.Array, len(v))
13764	for i := range v {
13765		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13766	}
13767
13768	return ret
13769}
13770
13771func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
13772	if v == nil {
13773		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13774			ec.Errorf(ctx, "must not be null")
13775		}
13776		return graphql.Null
13777	}
13778	return ec._Identity(ctx, sel, v)
13779}
13780
13781func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterfaceᚄ(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
13782	ret := make(graphql.Array, len(v))
13783	var wg sync.WaitGroup
13784	isLen1 := len(v) == 1
13785	if !isLen1 {
13786		wg.Add(len(v))
13787	}
13788	for i := range v {
13789		i := i
13790		fc := &graphql.FieldContext{
13791			Index:  &i,
13792			Result: &v[i],
13793		}
13794		ctx := graphql.WithFieldContext(ctx, fc)
13795		f := func(i int) {
13796			defer func() {
13797				if r := recover(); r != nil {
13798					ec.Error(ctx, ec.Recover(ctx, r))
13799					ret = nil
13800				}
13801			}()
13802			if !isLen1 {
13803				defer wg.Done()
13804			}
13805			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
13806		}
13807		if isLen1 {
13808			f(i)
13809		} else {
13810			go f(i)
13811		}
13812
13813	}
13814	wg.Wait()
13815	return ret
13816}
13817
13818func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13819	return ec._IdentityConnection(ctx, sel, &v)
13820}
13821
13822func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13823	if v == nil {
13824		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13825			ec.Errorf(ctx, "must not be null")
13826		}
13827		return graphql.Null
13828	}
13829	return ec._IdentityConnection(ctx, sel, v)
13830}
13831
13832func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13833	return ec._IdentityEdge(ctx, sel, &v)
13834}
13835
13836func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13837	ret := make(graphql.Array, len(v))
13838	var wg sync.WaitGroup
13839	isLen1 := len(v) == 1
13840	if !isLen1 {
13841		wg.Add(len(v))
13842	}
13843	for i := range v {
13844		i := i
13845		fc := &graphql.FieldContext{
13846			Index:  &i,
13847			Result: &v[i],
13848		}
13849		ctx := graphql.WithFieldContext(ctx, fc)
13850		f := func(i int) {
13851			defer func() {
13852				if r := recover(); r != nil {
13853					ec.Error(ctx, ec.Recover(ctx, r))
13854					ret = nil
13855				}
13856			}()
13857			if !isLen1 {
13858				defer wg.Done()
13859			}
13860			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13861		}
13862		if isLen1 {
13863			f(i)
13864		} else {
13865			go f(i)
13866		}
13867
13868	}
13869	wg.Wait()
13870	return ret
13871}
13872
13873func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13874	if v == nil {
13875		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13876			ec.Errorf(ctx, "must not be null")
13877		}
13878		return graphql.Null
13879	}
13880	return ec._IdentityEdge(ctx, sel, v)
13881}
13882
13883func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13884	return graphql.UnmarshalInt(v)
13885}
13886
13887func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13888	res := graphql.MarshalInt(v)
13889	if res == graphql.Null {
13890		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13891			ec.Errorf(ctx, "must not be null")
13892		}
13893	}
13894	return res
13895}
13896
13897func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13898	return ec._Label(ctx, sel, &v)
13899}
13900
13901func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13902	ret := make(graphql.Array, len(v))
13903	var wg sync.WaitGroup
13904	isLen1 := len(v) == 1
13905	if !isLen1 {
13906		wg.Add(len(v))
13907	}
13908	for i := range v {
13909		i := i
13910		fc := &graphql.FieldContext{
13911			Index:  &i,
13912			Result: &v[i],
13913		}
13914		ctx := graphql.WithFieldContext(ctx, fc)
13915		f := func(i int) {
13916			defer func() {
13917				if r := recover(); r != nil {
13918					ec.Error(ctx, ec.Recover(ctx, r))
13919					ret = nil
13920				}
13921			}()
13922			if !isLen1 {
13923				defer wg.Done()
13924			}
13925			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13926		}
13927		if isLen1 {
13928			f(i)
13929		} else {
13930			go f(i)
13931		}
13932
13933	}
13934	wg.Wait()
13935	return ret
13936}
13937
13938func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13939	return ec._LabelChangeOperation(ctx, sel, &v)
13940}
13941
13942func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13943	if v == nil {
13944		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13945			ec.Errorf(ctx, "must not be null")
13946		}
13947		return graphql.Null
13948	}
13949	return ec._LabelChangeOperation(ctx, sel, v)
13950}
13951
13952func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13953	ret := make(graphql.Array, len(v))
13954	var wg sync.WaitGroup
13955	isLen1 := len(v) == 1
13956	if !isLen1 {
13957		wg.Add(len(v))
13958	}
13959	for i := range v {
13960		i := i
13961		fc := &graphql.FieldContext{
13962			Index:  &i,
13963			Result: &v[i],
13964		}
13965		ctx := graphql.WithFieldContext(ctx, fc)
13966		f := func(i int) {
13967			defer func() {
13968				if r := recover(); r != nil {
13969					ec.Error(ctx, ec.Recover(ctx, r))
13970					ret = nil
13971				}
13972			}()
13973			if !isLen1 {
13974				defer wg.Done()
13975			}
13976			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13977		}
13978		if isLen1 {
13979			f(i)
13980		} else {
13981			go f(i)
13982		}
13983
13984	}
13985	wg.Wait()
13986	return ret
13987}
13988
13989func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13990	var res models.LabelChangeStatus
13991	return res, res.UnmarshalGQL(v)
13992}
13993
13994func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13995	return v
13996}
13997
13998func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13999	return ec._LabelConnection(ctx, sel, &v)
14000}
14001
14002func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
14003	if v == nil {
14004		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14005			ec.Errorf(ctx, "must not be null")
14006		}
14007		return graphql.Null
14008	}
14009	return ec._LabelConnection(ctx, sel, v)
14010}
14011
14012func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
14013	return ec._LabelEdge(ctx, sel, &v)
14014}
14015
14016func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
14017	ret := make(graphql.Array, len(v))
14018	var wg sync.WaitGroup
14019	isLen1 := len(v) == 1
14020	if !isLen1 {
14021		wg.Add(len(v))
14022	}
14023	for i := range v {
14024		i := i
14025		fc := &graphql.FieldContext{
14026			Index:  &i,
14027			Result: &v[i],
14028		}
14029		ctx := graphql.WithFieldContext(ctx, fc)
14030		f := func(i int) {
14031			defer func() {
14032				if r := recover(); r != nil {
14033					ec.Error(ctx, ec.Recover(ctx, r))
14034					ret = nil
14035				}
14036			}()
14037			if !isLen1 {
14038				defer wg.Done()
14039			}
14040			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
14041		}
14042		if isLen1 {
14043			f(i)
14044		} else {
14045			go f(i)
14046		}
14047
14048	}
14049	wg.Wait()
14050	return ret
14051}
14052
14053func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
14054	if v == nil {
14055		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14056			ec.Errorf(ctx, "must not be null")
14057		}
14058		return graphql.Null
14059	}
14060	return ec._LabelEdge(ctx, sel, v)
14061}
14062
14063func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
14064	return ec.unmarshalInputNewBugInput(ctx, v)
14065}
14066
14067func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
14068	return ec._NewBugPayload(ctx, sel, &v)
14069}
14070
14071func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
14072	if v == nil {
14073		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14074			ec.Errorf(ctx, "must not be null")
14075		}
14076		return graphql.Null
14077	}
14078	return ec._NewBugPayload(ctx, sel, v)
14079}
14080
14081func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
14082	return ec.unmarshalInputOpenBugInput(ctx, v)
14083}
14084
14085func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
14086	return ec._OpenBugPayload(ctx, sel, &v)
14087}
14088
14089func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
14090	if v == nil {
14091		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14092			ec.Errorf(ctx, "must not be null")
14093		}
14094		return graphql.Null
14095	}
14096	return ec._OpenBugPayload(ctx, sel, v)
14097}
14098
14099func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
14100	if v == nil {
14101		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14102			ec.Errorf(ctx, "must not be null")
14103		}
14104		return graphql.Null
14105	}
14106	return ec._Operation(ctx, sel, v)
14107}
14108
14109func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
14110	ret := make(graphql.Array, len(v))
14111	var wg sync.WaitGroup
14112	isLen1 := len(v) == 1
14113	if !isLen1 {
14114		wg.Add(len(v))
14115	}
14116	for i := range v {
14117		i := i
14118		fc := &graphql.FieldContext{
14119			Index:  &i,
14120			Result: &v[i],
14121		}
14122		ctx := graphql.WithFieldContext(ctx, fc)
14123		f := func(i int) {
14124			defer func() {
14125				if r := recover(); r != nil {
14126					ec.Error(ctx, ec.Recover(ctx, r))
14127					ret = nil
14128				}
14129			}()
14130			if !isLen1 {
14131				defer wg.Done()
14132			}
14133			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
14134		}
14135		if isLen1 {
14136			f(i)
14137		} else {
14138			go f(i)
14139		}
14140
14141	}
14142	wg.Wait()
14143	return ret
14144}
14145
14146func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
14147	return ec._OperationConnection(ctx, sel, &v)
14148}
14149
14150func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
14151	if v == nil {
14152		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14153			ec.Errorf(ctx, "must not be null")
14154		}
14155		return graphql.Null
14156	}
14157	return ec._OperationConnection(ctx, sel, v)
14158}
14159
14160func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
14161	return ec._OperationEdge(ctx, sel, &v)
14162}
14163
14164func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
14165	ret := make(graphql.Array, len(v))
14166	var wg sync.WaitGroup
14167	isLen1 := len(v) == 1
14168	if !isLen1 {
14169		wg.Add(len(v))
14170	}
14171	for i := range v {
14172		i := i
14173		fc := &graphql.FieldContext{
14174			Index:  &i,
14175			Result: &v[i],
14176		}
14177		ctx := graphql.WithFieldContext(ctx, fc)
14178		f := func(i int) {
14179			defer func() {
14180				if r := recover(); r != nil {
14181					ec.Error(ctx, ec.Recover(ctx, r))
14182					ret = nil
14183				}
14184			}()
14185			if !isLen1 {
14186				defer wg.Done()
14187			}
14188			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
14189		}
14190		if isLen1 {
14191			f(i)
14192		} else {
14193			go f(i)
14194		}
14195
14196	}
14197	wg.Wait()
14198	return ret
14199}
14200
14201func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14202	if v == nil {
14203		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14204			ec.Errorf(ctx, "must not be null")
14205		}
14206		return graphql.Null
14207	}
14208	return ec._OperationEdge(ctx, sel, v)
14209}
14210
14211func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14212	return ec._PageInfo(ctx, sel, &v)
14213}
14214
14215func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14216	if v == nil {
14217		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14218			ec.Errorf(ctx, "must not be null")
14219		}
14220		return graphql.Null
14221	}
14222	return ec._PageInfo(ctx, sel, v)
14223}
14224
14225func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14226	return ec._SetStatusOperation(ctx, sel, &v)
14227}
14228
14229func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14230	if v == nil {
14231		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14232			ec.Errorf(ctx, "must not be null")
14233		}
14234		return graphql.Null
14235	}
14236	return ec._SetStatusOperation(ctx, sel, v)
14237}
14238
14239func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14240	return ec.unmarshalInputSetTitleInput(ctx, v)
14241}
14242
14243func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14244	return ec._SetTitleOperation(ctx, sel, &v)
14245}
14246
14247func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14248	if v == nil {
14249		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14250			ec.Errorf(ctx, "must not be null")
14251		}
14252		return graphql.Null
14253	}
14254	return ec._SetTitleOperation(ctx, sel, v)
14255}
14256
14257func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14258	return ec._SetTitlePayload(ctx, sel, &v)
14259}
14260
14261func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14262	if v == nil {
14263		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14264			ec.Errorf(ctx, "must not be null")
14265		}
14266		return graphql.Null
14267	}
14268	return ec._SetTitlePayload(ctx, sel, v)
14269}
14270
14271func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14272	var res models.Status
14273	return res, res.UnmarshalGQL(v)
14274}
14275
14276func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14277	return v
14278}
14279
14280func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14281	return graphql.UnmarshalString(v)
14282}
14283
14284func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14285	res := graphql.MarshalString(v)
14286	if res == graphql.Null {
14287		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14288			ec.Errorf(ctx, "must not be null")
14289		}
14290	}
14291	return res
14292}
14293
14294func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14295	return graphql.UnmarshalTime(v)
14296}
14297
14298func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14299	res := graphql.MarshalTime(v)
14300	if res == graphql.Null {
14301		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14302			ec.Errorf(ctx, "must not be null")
14303		}
14304	}
14305	return res
14306}
14307
14308func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14309	if v == nil {
14310		return nil, nil
14311	}
14312	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14313	return &res, err
14314}
14315
14316func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14317	if v == nil {
14318		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14319			ec.Errorf(ctx, "must not be null")
14320		}
14321		return graphql.Null
14322	}
14323	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14324}
14325
14326func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14327	if v == nil {
14328		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14329			ec.Errorf(ctx, "must not be null")
14330		}
14331		return graphql.Null
14332	}
14333	return ec._TimelineItem(ctx, sel, v)
14334}
14335
14336func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14337	ret := make(graphql.Array, len(v))
14338	var wg sync.WaitGroup
14339	isLen1 := len(v) == 1
14340	if !isLen1 {
14341		wg.Add(len(v))
14342	}
14343	for i := range v {
14344		i := i
14345		fc := &graphql.FieldContext{
14346			Index:  &i,
14347			Result: &v[i],
14348		}
14349		ctx := graphql.WithFieldContext(ctx, fc)
14350		f := func(i int) {
14351			defer func() {
14352				if r := recover(); r != nil {
14353					ec.Error(ctx, ec.Recover(ctx, r))
14354					ret = nil
14355				}
14356			}()
14357			if !isLen1 {
14358				defer wg.Done()
14359			}
14360			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14361		}
14362		if isLen1 {
14363			f(i)
14364		} else {
14365			go f(i)
14366		}
14367
14368	}
14369	wg.Wait()
14370	return ret
14371}
14372
14373func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14374	return ec._TimelineItemConnection(ctx, sel, &v)
14375}
14376
14377func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14378	if v == nil {
14379		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14380			ec.Errorf(ctx, "must not be null")
14381		}
14382		return graphql.Null
14383	}
14384	return ec._TimelineItemConnection(ctx, sel, v)
14385}
14386
14387func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14388	return ec._TimelineItemEdge(ctx, sel, &v)
14389}
14390
14391func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14392	ret := make(graphql.Array, len(v))
14393	var wg sync.WaitGroup
14394	isLen1 := len(v) == 1
14395	if !isLen1 {
14396		wg.Add(len(v))
14397	}
14398	for i := range v {
14399		i := i
14400		fc := &graphql.FieldContext{
14401			Index:  &i,
14402			Result: &v[i],
14403		}
14404		ctx := graphql.WithFieldContext(ctx, fc)
14405		f := func(i int) {
14406			defer func() {
14407				if r := recover(); r != nil {
14408					ec.Error(ctx, ec.Recover(ctx, r))
14409					ret = nil
14410				}
14411			}()
14412			if !isLen1 {
14413				defer wg.Done()
14414			}
14415			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14416		}
14417		if isLen1 {
14418			f(i)
14419		} else {
14420			go f(i)
14421		}
14422
14423	}
14424	wg.Wait()
14425	return ret
14426}
14427
14428func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14429	if v == nil {
14430		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14431			ec.Errorf(ctx, "must not be null")
14432		}
14433		return graphql.Null
14434	}
14435	return ec._TimelineItemEdge(ctx, sel, v)
14436}
14437
14438func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14439	return ec.___Directive(ctx, sel, &v)
14440}
14441
14442func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14443	ret := make(graphql.Array, len(v))
14444	var wg sync.WaitGroup
14445	isLen1 := len(v) == 1
14446	if !isLen1 {
14447		wg.Add(len(v))
14448	}
14449	for i := range v {
14450		i := i
14451		fc := &graphql.FieldContext{
14452			Index:  &i,
14453			Result: &v[i],
14454		}
14455		ctx := graphql.WithFieldContext(ctx, fc)
14456		f := func(i int) {
14457			defer func() {
14458				if r := recover(); r != nil {
14459					ec.Error(ctx, ec.Recover(ctx, r))
14460					ret = nil
14461				}
14462			}()
14463			if !isLen1 {
14464				defer wg.Done()
14465			}
14466			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14467		}
14468		if isLen1 {
14469			f(i)
14470		} else {
14471			go f(i)
14472		}
14473
14474	}
14475	wg.Wait()
14476	return ret
14477}
14478
14479func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14480	return graphql.UnmarshalString(v)
14481}
14482
14483func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14484	res := graphql.MarshalString(v)
14485	if res == graphql.Null {
14486		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14487			ec.Errorf(ctx, "must not be null")
14488		}
14489	}
14490	return res
14491}
14492
14493func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14494	var vSlice []interface{}
14495	if v != nil {
14496		if tmp1, ok := v.([]interface{}); ok {
14497			vSlice = tmp1
14498		} else {
14499			vSlice = []interface{}{v}
14500		}
14501	}
14502	var err error
14503	res := make([]string, len(vSlice))
14504	for i := range vSlice {
14505		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14506		if err != nil {
14507			return nil, err
14508		}
14509	}
14510	return res, nil
14511}
14512
14513func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14514	ret := make(graphql.Array, len(v))
14515	var wg sync.WaitGroup
14516	isLen1 := len(v) == 1
14517	if !isLen1 {
14518		wg.Add(len(v))
14519	}
14520	for i := range v {
14521		i := i
14522		fc := &graphql.FieldContext{
14523			Index:  &i,
14524			Result: &v[i],
14525		}
14526		ctx := graphql.WithFieldContext(ctx, fc)
14527		f := func(i int) {
14528			defer func() {
14529				if r := recover(); r != nil {
14530					ec.Error(ctx, ec.Recover(ctx, r))
14531					ret = nil
14532				}
14533			}()
14534			if !isLen1 {
14535				defer wg.Done()
14536			}
14537			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14538		}
14539		if isLen1 {
14540			f(i)
14541		} else {
14542			go f(i)
14543		}
14544
14545	}
14546	wg.Wait()
14547	return ret
14548}
14549
14550func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14551	return ec.___EnumValue(ctx, sel, &v)
14552}
14553
14554func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14555	return ec.___Field(ctx, sel, &v)
14556}
14557
14558func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14559	return ec.___InputValue(ctx, sel, &v)
14560}
14561
14562func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14563	ret := make(graphql.Array, len(v))
14564	var wg sync.WaitGroup
14565	isLen1 := len(v) == 1
14566	if !isLen1 {
14567		wg.Add(len(v))
14568	}
14569	for i := range v {
14570		i := i
14571		fc := &graphql.FieldContext{
14572			Index:  &i,
14573			Result: &v[i],
14574		}
14575		ctx := graphql.WithFieldContext(ctx, fc)
14576		f := func(i int) {
14577			defer func() {
14578				if r := recover(); r != nil {
14579					ec.Error(ctx, ec.Recover(ctx, r))
14580					ret = nil
14581				}
14582			}()
14583			if !isLen1 {
14584				defer wg.Done()
14585			}
14586			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14587		}
14588		if isLen1 {
14589			f(i)
14590		} else {
14591			go f(i)
14592		}
14593
14594	}
14595	wg.Wait()
14596	return ret
14597}
14598
14599func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14600	return ec.___Type(ctx, sel, &v)
14601}
14602
14603func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14604	ret := make(graphql.Array, len(v))
14605	var wg sync.WaitGroup
14606	isLen1 := len(v) == 1
14607	if !isLen1 {
14608		wg.Add(len(v))
14609	}
14610	for i := range v {
14611		i := i
14612		fc := &graphql.FieldContext{
14613			Index:  &i,
14614			Result: &v[i],
14615		}
14616		ctx := graphql.WithFieldContext(ctx, fc)
14617		f := func(i int) {
14618			defer func() {
14619				if r := recover(); r != nil {
14620					ec.Error(ctx, ec.Recover(ctx, r))
14621					ret = nil
14622				}
14623			}()
14624			if !isLen1 {
14625				defer wg.Done()
14626			}
14627			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14628		}
14629		if isLen1 {
14630			f(i)
14631		} else {
14632			go f(i)
14633		}
14634
14635	}
14636	wg.Wait()
14637	return ret
14638}
14639
14640func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14641	if v == nil {
14642		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14643			ec.Errorf(ctx, "must not be null")
14644		}
14645		return graphql.Null
14646	}
14647	return ec.___Type(ctx, sel, v)
14648}
14649
14650func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14651	return graphql.UnmarshalString(v)
14652}
14653
14654func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14655	res := graphql.MarshalString(v)
14656	if res == graphql.Null {
14657		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14658			ec.Errorf(ctx, "must not be null")
14659		}
14660	}
14661	return res
14662}
14663
14664func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14665	return graphql.UnmarshalBoolean(v)
14666}
14667
14668func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14669	return graphql.MarshalBoolean(v)
14670}
14671
14672func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14673	if v == nil {
14674		return nil, nil
14675	}
14676	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14677	return &res, err
14678}
14679
14680func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14681	if v == nil {
14682		return graphql.Null
14683	}
14684	return ec.marshalOBoolean2bool(ctx, sel, *v)
14685}
14686
14687func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
14688	return ec._Bug(ctx, sel, &v)
14689}
14690
14691func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
14692	if v == nil {
14693		return graphql.Null
14694	}
14695	return ec._Bug(ctx, sel, v)
14696}
14697
14698func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14699	return ec.unmarshalInputChangeLabelInput(ctx, v)
14700}
14701
14702func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14703	if v == nil {
14704		return nil, nil
14705	}
14706	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14707	return &res, err
14708}
14709
14710func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14711	var vSlice []interface{}
14712	if v != nil {
14713		if tmp1, ok := v.([]interface{}); ok {
14714			vSlice = tmp1
14715		} else {
14716			vSlice = []interface{}{v}
14717		}
14718	}
14719	var err error
14720	res := make([]git.Hash, len(vSlice))
14721	for i := range vSlice {
14722		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14723		if err != nil {
14724			return nil, err
14725		}
14726	}
14727	return res, nil
14728}
14729
14730func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14731	if v == nil {
14732		return graphql.Null
14733	}
14734	ret := make(graphql.Array, len(v))
14735	for i := range v {
14736		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14737	}
14738
14739	return ret
14740}
14741
14742func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
14743	if v == nil {
14744		return graphql.Null
14745	}
14746	return ec._Identity(ctx, sel, v)
14747}
14748
14749func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14750	return graphql.UnmarshalInt(v)
14751}
14752
14753func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14754	return graphql.MarshalInt(v)
14755}
14756
14757func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14758	if v == nil {
14759		return nil, nil
14760	}
14761	res, err := ec.unmarshalOInt2int(ctx, v)
14762	return &res, err
14763}
14764
14765func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14766	if v == nil {
14767		return graphql.Null
14768	}
14769	return ec.marshalOInt2int(ctx, sel, *v)
14770}
14771
14772func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14773	return ec._LabelChangeResult(ctx, sel, &v)
14774}
14775
14776func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14777	if v == nil {
14778		return graphql.Null
14779	}
14780	return ec._LabelChangeResult(ctx, sel, v)
14781}
14782
14783func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14784	return ec._Repository(ctx, sel, &v)
14785}
14786
14787func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14788	if v == nil {
14789		return graphql.Null
14790	}
14791	return ec._Repository(ctx, sel, v)
14792}
14793
14794func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14795	return graphql.UnmarshalString(v)
14796}
14797
14798func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14799	return graphql.MarshalString(v)
14800}
14801
14802func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14803	var vSlice []interface{}
14804	if v != nil {
14805		if tmp1, ok := v.([]interface{}); ok {
14806			vSlice = tmp1
14807		} else {
14808			vSlice = []interface{}{v}
14809		}
14810	}
14811	var err error
14812	res := make([]string, len(vSlice))
14813	for i := range vSlice {
14814		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14815		if err != nil {
14816			return nil, err
14817		}
14818	}
14819	return res, nil
14820}
14821
14822func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14823	if v == nil {
14824		return graphql.Null
14825	}
14826	ret := make(graphql.Array, len(v))
14827	for i := range v {
14828		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14829	}
14830
14831	return ret
14832}
14833
14834func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14835	if v == nil {
14836		return nil, nil
14837	}
14838	res, err := ec.unmarshalOString2string(ctx, v)
14839	return &res, err
14840}
14841
14842func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14843	if v == nil {
14844		return graphql.Null
14845	}
14846	return ec.marshalOString2string(ctx, sel, *v)
14847}
14848
14849func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14850	if v == nil {
14851		return graphql.Null
14852	}
14853	ret := make(graphql.Array, len(v))
14854	var wg sync.WaitGroup
14855	isLen1 := len(v) == 1
14856	if !isLen1 {
14857		wg.Add(len(v))
14858	}
14859	for i := range v {
14860		i := i
14861		fc := &graphql.FieldContext{
14862			Index:  &i,
14863			Result: &v[i],
14864		}
14865		ctx := graphql.WithFieldContext(ctx, fc)
14866		f := func(i int) {
14867			defer func() {
14868				if r := recover(); r != nil {
14869					ec.Error(ctx, ec.Recover(ctx, r))
14870					ret = nil
14871				}
14872			}()
14873			if !isLen1 {
14874				defer wg.Done()
14875			}
14876			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14877		}
14878		if isLen1 {
14879			f(i)
14880		} else {
14881			go f(i)
14882		}
14883
14884	}
14885	wg.Wait()
14886	return ret
14887}
14888
14889func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14890	if v == nil {
14891		return graphql.Null
14892	}
14893	ret := make(graphql.Array, len(v))
14894	var wg sync.WaitGroup
14895	isLen1 := len(v) == 1
14896	if !isLen1 {
14897		wg.Add(len(v))
14898	}
14899	for i := range v {
14900		i := i
14901		fc := &graphql.FieldContext{
14902			Index:  &i,
14903			Result: &v[i],
14904		}
14905		ctx := graphql.WithFieldContext(ctx, fc)
14906		f := func(i int) {
14907			defer func() {
14908				if r := recover(); r != nil {
14909					ec.Error(ctx, ec.Recover(ctx, r))
14910					ret = nil
14911				}
14912			}()
14913			if !isLen1 {
14914				defer wg.Done()
14915			}
14916			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14917		}
14918		if isLen1 {
14919			f(i)
14920		} else {
14921			go f(i)
14922		}
14923
14924	}
14925	wg.Wait()
14926	return ret
14927}
14928
14929func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14930	if v == nil {
14931		return graphql.Null
14932	}
14933	ret := make(graphql.Array, len(v))
14934	var wg sync.WaitGroup
14935	isLen1 := len(v) == 1
14936	if !isLen1 {
14937		wg.Add(len(v))
14938	}
14939	for i := range v {
14940		i := i
14941		fc := &graphql.FieldContext{
14942			Index:  &i,
14943			Result: &v[i],
14944		}
14945		ctx := graphql.WithFieldContext(ctx, fc)
14946		f := func(i int) {
14947			defer func() {
14948				if r := recover(); r != nil {
14949					ec.Error(ctx, ec.Recover(ctx, r))
14950					ret = nil
14951				}
14952			}()
14953			if !isLen1 {
14954				defer wg.Done()
14955			}
14956			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14957		}
14958		if isLen1 {
14959			f(i)
14960		} else {
14961			go f(i)
14962		}
14963
14964	}
14965	wg.Wait()
14966	return ret
14967}
14968
14969func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14970	return ec.___Schema(ctx, sel, &v)
14971}
14972
14973func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14974	if v == nil {
14975		return graphql.Null
14976	}
14977	return ec.___Schema(ctx, sel, v)
14978}
14979
14980func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14981	return ec.___Type(ctx, sel, &v)
14982}
14983
14984func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14985	if v == nil {
14986		return graphql.Null
14987	}
14988	ret := make(graphql.Array, len(v))
14989	var wg sync.WaitGroup
14990	isLen1 := len(v) == 1
14991	if !isLen1 {
14992		wg.Add(len(v))
14993	}
14994	for i := range v {
14995		i := i
14996		fc := &graphql.FieldContext{
14997			Index:  &i,
14998			Result: &v[i],
14999		}
15000		ctx := graphql.WithFieldContext(ctx, fc)
15001		f := func(i int) {
15002			defer func() {
15003				if r := recover(); r != nil {
15004					ec.Error(ctx, ec.Recover(ctx, r))
15005					ret = nil
15006				}
15007			}()
15008			if !isLen1 {
15009				defer wg.Done()
15010			}
15011			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
15012		}
15013		if isLen1 {
15014			f(i)
15015		} else {
15016			go f(i)
15017		}
15018
15019	}
15020	wg.Wait()
15021	return ret
15022}
15023
15024func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
15025	if v == nil {
15026		return graphql.Null
15027	}
15028	return ec.___Type(ctx, sel, v)
15029}
15030
15031// endregion ***************************** type.gotpl *****************************