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/util/git"
   21	"github.com/vektah/gqlparser"
   22	"github.com/vektah/gqlparser/ast"
   23)
   24
   25// region    ************************** generated!.gotpl **************************
   26
   27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
   28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
   29	return &executableSchema{
   30		resolvers:  cfg.Resolvers,
   31		directives: cfg.Directives,
   32		complexity: cfg.Complexity,
   33	}
   34}
   35
   36type Config struct {
   37	Resolvers  ResolverRoot
   38	Directives DirectiveRoot
   39	Complexity ComplexityRoot
   40}
   41
   42type ResolverRoot interface {
   43	AddCommentOperation() AddCommentOperationResolver
   44	AddCommentTimelineItem() AddCommentTimelineItemResolver
   45	Bug() BugResolver
   46	Color() ColorResolver
   47	Comment() CommentResolver
   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	CreateOperation struct {
  167		Author  func(childComplexity int) int
  168		Date    func(childComplexity int) int
  169		Files   func(childComplexity int) int
  170		ID      func(childComplexity int) int
  171		Message func(childComplexity int) int
  172		Title   func(childComplexity int) int
  173	}
  174
  175	CreateTimelineItem struct {
  176		Author         func(childComplexity int) int
  177		CreatedAt      func(childComplexity int) int
  178		Edited         func(childComplexity int) int
  179		Files          func(childComplexity int) int
  180		History        func(childComplexity int) int
  181		ID             func(childComplexity int) int
  182		LastEdit       func(childComplexity int) int
  183		Message        func(childComplexity int) int
  184		MessageIsEmpty func(childComplexity int) int
  185	}
  186
  187	EditCommentOperation struct {
  188		Author  func(childComplexity int) int
  189		Date    func(childComplexity int) int
  190		Files   func(childComplexity int) int
  191		ID      func(childComplexity int) int
  192		Message func(childComplexity int) int
  193		Target  func(childComplexity int) int
  194	}
  195
  196	Identity struct {
  197		AvatarUrl   func(childComplexity int) int
  198		DisplayName func(childComplexity int) int
  199		Email       func(childComplexity int) int
  200		HumanID     func(childComplexity int) int
  201		ID          func(childComplexity int) int
  202		IsProtected func(childComplexity int) int
  203		Login       func(childComplexity int) int
  204		Name        func(childComplexity int) int
  205	}
  206
  207	IdentityConnection struct {
  208		Edges      func(childComplexity int) int
  209		Nodes      func(childComplexity int) int
  210		PageInfo   func(childComplexity int) int
  211		TotalCount func(childComplexity int) int
  212	}
  213
  214	IdentityEdge struct {
  215		Cursor func(childComplexity int) int
  216		Node   func(childComplexity int) int
  217	}
  218
  219	Label struct {
  220		Color func(childComplexity int) int
  221		Name  func(childComplexity int) int
  222	}
  223
  224	LabelChangeOperation struct {
  225		Added   func(childComplexity int) int
  226		Author  func(childComplexity int) int
  227		Date    func(childComplexity int) int
  228		ID      func(childComplexity int) int
  229		Removed func(childComplexity int) int
  230	}
  231
  232	LabelChangeResult struct {
  233		Label  func(childComplexity int) int
  234		Status func(childComplexity int) int
  235	}
  236
  237	LabelChangeTimelineItem struct {
  238		Added   func(childComplexity int) int
  239		Author  func(childComplexity int) int
  240		Date    func(childComplexity int) int
  241		ID      func(childComplexity int) int
  242		Removed func(childComplexity int) int
  243	}
  244
  245	LabelConnection struct {
  246		Edges      func(childComplexity int) int
  247		Nodes      func(childComplexity int) int
  248		PageInfo   func(childComplexity int) int
  249		TotalCount func(childComplexity int) int
  250	}
  251
  252	LabelEdge struct {
  253		Cursor func(childComplexity int) int
  254		Node   func(childComplexity int) int
  255	}
  256
  257	Mutation struct {
  258		AddComment   func(childComplexity int, input models.AddCommentInput) int
  259		ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
  260		CloseBug     func(childComplexity int, input models.CloseBugInput) int
  261		NewBug       func(childComplexity int, input models.NewBugInput) int
  262		OpenBug      func(childComplexity int, input models.OpenBugInput) int
  263		SetTitle     func(childComplexity int, input models.SetTitleInput) int
  264	}
  265
  266	NewBugPayload struct {
  267		Bug              func(childComplexity int) int
  268		ClientMutationID func(childComplexity int) int
  269		Operation        func(childComplexity int) int
  270	}
  271
  272	OpenBugPayload struct {
  273		Bug              func(childComplexity int) int
  274		ClientMutationID func(childComplexity int) int
  275		Operation        func(childComplexity int) int
  276	}
  277
  278	OperationConnection struct {
  279		Edges      func(childComplexity int) int
  280		Nodes      func(childComplexity int) int
  281		PageInfo   func(childComplexity int) int
  282		TotalCount func(childComplexity int) int
  283	}
  284
  285	OperationEdge struct {
  286		Cursor func(childComplexity int) int
  287		Node   func(childComplexity int) int
  288	}
  289
  290	PageInfo struct {
  291		EndCursor       func(childComplexity int) int
  292		HasNextPage     func(childComplexity int) int
  293		HasPreviousPage func(childComplexity int) int
  294		StartCursor     func(childComplexity int) int
  295	}
  296
  297	Query struct {
  298		Repository func(childComplexity int, ref *string) int
  299	}
  300
  301	Repository struct {
  302		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  303		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  304		Bug           func(childComplexity int, prefix string) int
  305		Identity      func(childComplexity int, prefix string) int
  306		Name          func(childComplexity int) int
  307		UserIdentity  func(childComplexity int) int
  308		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  309	}
  310
  311	SetStatusOperation struct {
  312		Author func(childComplexity int) int
  313		Date   func(childComplexity int) int
  314		ID     func(childComplexity int) int
  315		Status func(childComplexity int) int
  316	}
  317
  318	SetStatusTimelineItem struct {
  319		Author func(childComplexity int) int
  320		Date   func(childComplexity int) int
  321		ID     func(childComplexity int) int
  322		Status func(childComplexity int) int
  323	}
  324
  325	SetTitleOperation struct {
  326		Author func(childComplexity int) int
  327		Date   func(childComplexity int) int
  328		ID     func(childComplexity int) int
  329		Title  func(childComplexity int) int
  330		Was    func(childComplexity int) int
  331	}
  332
  333	SetTitlePayload struct {
  334		Bug              func(childComplexity int) int
  335		ClientMutationID func(childComplexity int) int
  336		Operation        func(childComplexity int) int
  337	}
  338
  339	SetTitleTimelineItem struct {
  340		Author func(childComplexity int) int
  341		Date   func(childComplexity int) int
  342		ID     func(childComplexity int) int
  343		Title  func(childComplexity int) int
  344		Was    func(childComplexity int) int
  345	}
  346
  347	TimelineItemConnection struct {
  348		Edges      func(childComplexity int) int
  349		Nodes      func(childComplexity int) int
  350		PageInfo   func(childComplexity int) int
  351		TotalCount func(childComplexity int) int
  352	}
  353
  354	TimelineItemEdge struct {
  355		Cursor func(childComplexity int) int
  356		Node   func(childComplexity int) int
  357	}
  358}
  359
  360type AddCommentOperationResolver interface {
  361	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  362	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
  363	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  364}
  365type AddCommentTimelineItemResolver interface {
  366	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  367	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
  368
  369	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  370	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  371}
  372type BugResolver interface {
  373	ID(ctx context.Context, obj models.BugWrapper) (string, error)
  374	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  375	Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
  376
  377	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  378	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  379	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  380	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  381	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  382}
  383type ColorResolver interface {
  384	R(ctx context.Context, obj *color.RGBA) (int, error)
  385	G(ctx context.Context, obj *color.RGBA) (int, error)
  386	B(ctx context.Context, obj *color.RGBA) (int, error)
  387}
  388type CommentResolver interface {
  389	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
  390}
  391type CommentHistoryStepResolver interface {
  392	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  393}
  394type CreateOperationResolver interface {
  395	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  396	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
  397	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  398}
  399type CreateTimelineItemResolver interface {
  400	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  401	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
  402
  403	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  404	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  405}
  406type EditCommentOperationResolver interface {
  407	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  408	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
  409	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  410	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  411}
  412type IdentityResolver interface {
  413	ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  414	HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  415}
  416type LabelResolver interface {
  417	Name(ctx context.Context, obj *bug.Label) (string, error)
  418	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  419}
  420type LabelChangeOperationResolver interface {
  421	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  422	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
  423	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  424}
  425type LabelChangeResultResolver interface {
  426	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  427}
  428type LabelChangeTimelineItemResolver interface {
  429	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  430	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
  431	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  432}
  433type MutationResolver interface {
  434	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  435	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  436	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  437	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  438	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  439	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  440}
  441type QueryResolver interface {
  442	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  443}
  444type RepositoryResolver interface {
  445	Name(ctx context.Context, obj *models.Repository) (*string, error)
  446	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  447	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  448	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  449	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  450	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  451	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  452}
  453type SetStatusOperationResolver interface {
  454	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  455	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
  456	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  457	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  458}
  459type SetStatusTimelineItemResolver interface {
  460	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  461	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
  462	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  463	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  464}
  465type SetTitleOperationResolver interface {
  466	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  467	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
  468	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  469}
  470type SetTitleTimelineItemResolver interface {
  471	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  472	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
  473	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  474}
  475
  476type executableSchema struct {
  477	resolvers  ResolverRoot
  478	directives DirectiveRoot
  479	complexity ComplexityRoot
  480}
  481
  482func (e *executableSchema) Schema() *ast.Schema {
  483	return parsedSchema
  484}
  485
  486func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  487	ec := executionContext{nil, e}
  488	_ = ec
  489	switch typeName + "." + field {
  490
  491	case "AddCommentOperation.author":
  492		if e.complexity.AddCommentOperation.Author == nil {
  493			break
  494		}
  495
  496		return e.complexity.AddCommentOperation.Author(childComplexity), true
  497
  498	case "AddCommentOperation.date":
  499		if e.complexity.AddCommentOperation.Date == nil {
  500			break
  501		}
  502
  503		return e.complexity.AddCommentOperation.Date(childComplexity), true
  504
  505	case "AddCommentOperation.files":
  506		if e.complexity.AddCommentOperation.Files == nil {
  507			break
  508		}
  509
  510		return e.complexity.AddCommentOperation.Files(childComplexity), true
  511
  512	case "AddCommentOperation.id":
  513		if e.complexity.AddCommentOperation.ID == nil {
  514			break
  515		}
  516
  517		return e.complexity.AddCommentOperation.ID(childComplexity), true
  518
  519	case "AddCommentOperation.message":
  520		if e.complexity.AddCommentOperation.Message == nil {
  521			break
  522		}
  523
  524		return e.complexity.AddCommentOperation.Message(childComplexity), true
  525
  526	case "AddCommentPayload.bug":
  527		if e.complexity.AddCommentPayload.Bug == nil {
  528			break
  529		}
  530
  531		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  532
  533	case "AddCommentPayload.clientMutationId":
  534		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  535			break
  536		}
  537
  538		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  539
  540	case "AddCommentPayload.operation":
  541		if e.complexity.AddCommentPayload.Operation == nil {
  542			break
  543		}
  544
  545		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  546
  547	case "AddCommentTimelineItem.author":
  548		if e.complexity.AddCommentTimelineItem.Author == nil {
  549			break
  550		}
  551
  552		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  553
  554	case "AddCommentTimelineItem.createdAt":
  555		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  556			break
  557		}
  558
  559		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  560
  561	case "AddCommentTimelineItem.edited":
  562		if e.complexity.AddCommentTimelineItem.Edited == nil {
  563			break
  564		}
  565
  566		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  567
  568	case "AddCommentTimelineItem.files":
  569		if e.complexity.AddCommentTimelineItem.Files == nil {
  570			break
  571		}
  572
  573		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  574
  575	case "AddCommentTimelineItem.history":
  576		if e.complexity.AddCommentTimelineItem.History == nil {
  577			break
  578		}
  579
  580		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  581
  582	case "AddCommentTimelineItem.id":
  583		if e.complexity.AddCommentTimelineItem.ID == nil {
  584			break
  585		}
  586
  587		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  588
  589	case "AddCommentTimelineItem.lastEdit":
  590		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  591			break
  592		}
  593
  594		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  595
  596	case "AddCommentTimelineItem.message":
  597		if e.complexity.AddCommentTimelineItem.Message == nil {
  598			break
  599		}
  600
  601		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  602
  603	case "AddCommentTimelineItem.messageIsEmpty":
  604		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  605			break
  606		}
  607
  608		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  609
  610	case "Bug.actors":
  611		if e.complexity.Bug.Actors == nil {
  612			break
  613		}
  614
  615		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  616		if err != nil {
  617			return 0, false
  618		}
  619
  620		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  621
  622	case "Bug.author":
  623		if e.complexity.Bug.Author == nil {
  624			break
  625		}
  626
  627		return e.complexity.Bug.Author(childComplexity), true
  628
  629	case "Bug.comments":
  630		if e.complexity.Bug.Comments == nil {
  631			break
  632		}
  633
  634		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  635		if err != nil {
  636			return 0, false
  637		}
  638
  639		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  640
  641	case "Bug.createdAt":
  642		if e.complexity.Bug.CreatedAt == nil {
  643			break
  644		}
  645
  646		return e.complexity.Bug.CreatedAt(childComplexity), true
  647
  648	case "Bug.humanId":
  649		if e.complexity.Bug.HumanID == nil {
  650			break
  651		}
  652
  653		return e.complexity.Bug.HumanID(childComplexity), true
  654
  655	case "Bug.id":
  656		if e.complexity.Bug.ID == nil {
  657			break
  658		}
  659
  660		return e.complexity.Bug.ID(childComplexity), true
  661
  662	case "Bug.labels":
  663		if e.complexity.Bug.Labels == nil {
  664			break
  665		}
  666
  667		return e.complexity.Bug.Labels(childComplexity), true
  668
  669	case "Bug.lastEdit":
  670		if e.complexity.Bug.LastEdit == nil {
  671			break
  672		}
  673
  674		return e.complexity.Bug.LastEdit(childComplexity), true
  675
  676	case "Bug.operations":
  677		if e.complexity.Bug.Operations == nil {
  678			break
  679		}
  680
  681		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  682		if err != nil {
  683			return 0, false
  684		}
  685
  686		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  687
  688	case "Bug.participants":
  689		if e.complexity.Bug.Participants == nil {
  690			break
  691		}
  692
  693		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  694		if err != nil {
  695			return 0, false
  696		}
  697
  698		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  699
  700	case "Bug.status":
  701		if e.complexity.Bug.Status == nil {
  702			break
  703		}
  704
  705		return e.complexity.Bug.Status(childComplexity), true
  706
  707	case "Bug.timeline":
  708		if e.complexity.Bug.Timeline == nil {
  709			break
  710		}
  711
  712		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  713		if err != nil {
  714			return 0, false
  715		}
  716
  717		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  718
  719	case "Bug.title":
  720		if e.complexity.Bug.Title == nil {
  721			break
  722		}
  723
  724		return e.complexity.Bug.Title(childComplexity), true
  725
  726	case "BugConnection.edges":
  727		if e.complexity.BugConnection.Edges == nil {
  728			break
  729		}
  730
  731		return e.complexity.BugConnection.Edges(childComplexity), true
  732
  733	case "BugConnection.nodes":
  734		if e.complexity.BugConnection.Nodes == nil {
  735			break
  736		}
  737
  738		return e.complexity.BugConnection.Nodes(childComplexity), true
  739
  740	case "BugConnection.pageInfo":
  741		if e.complexity.BugConnection.PageInfo == nil {
  742			break
  743		}
  744
  745		return e.complexity.BugConnection.PageInfo(childComplexity), true
  746
  747	case "BugConnection.totalCount":
  748		if e.complexity.BugConnection.TotalCount == nil {
  749			break
  750		}
  751
  752		return e.complexity.BugConnection.TotalCount(childComplexity), true
  753
  754	case "BugEdge.cursor":
  755		if e.complexity.BugEdge.Cursor == nil {
  756			break
  757		}
  758
  759		return e.complexity.BugEdge.Cursor(childComplexity), true
  760
  761	case "BugEdge.node":
  762		if e.complexity.BugEdge.Node == nil {
  763			break
  764		}
  765
  766		return e.complexity.BugEdge.Node(childComplexity), true
  767
  768	case "ChangeLabelPayload.bug":
  769		if e.complexity.ChangeLabelPayload.Bug == nil {
  770			break
  771		}
  772
  773		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  774
  775	case "ChangeLabelPayload.clientMutationId":
  776		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  777			break
  778		}
  779
  780		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  781
  782	case "ChangeLabelPayload.operation":
  783		if e.complexity.ChangeLabelPayload.Operation == nil {
  784			break
  785		}
  786
  787		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  788
  789	case "ChangeLabelPayload.results":
  790		if e.complexity.ChangeLabelPayload.Results == nil {
  791			break
  792		}
  793
  794		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  795
  796	case "CloseBugPayload.bug":
  797		if e.complexity.CloseBugPayload.Bug == nil {
  798			break
  799		}
  800
  801		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  802
  803	case "CloseBugPayload.clientMutationId":
  804		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  805			break
  806		}
  807
  808		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  809
  810	case "CloseBugPayload.operation":
  811		if e.complexity.CloseBugPayload.Operation == nil {
  812			break
  813		}
  814
  815		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  816
  817	case "Color.B":
  818		if e.complexity.Color.B == nil {
  819			break
  820		}
  821
  822		return e.complexity.Color.B(childComplexity), true
  823
  824	case "Color.G":
  825		if e.complexity.Color.G == nil {
  826			break
  827		}
  828
  829		return e.complexity.Color.G(childComplexity), true
  830
  831	case "Color.R":
  832		if e.complexity.Color.R == nil {
  833			break
  834		}
  835
  836		return e.complexity.Color.R(childComplexity), true
  837
  838	case "Comment.author":
  839		if e.complexity.Comment.Author == nil {
  840			break
  841		}
  842
  843		return e.complexity.Comment.Author(childComplexity), true
  844
  845	case "Comment.files":
  846		if e.complexity.Comment.Files == nil {
  847			break
  848		}
  849
  850		return e.complexity.Comment.Files(childComplexity), true
  851
  852	case "Comment.message":
  853		if e.complexity.Comment.Message == nil {
  854			break
  855		}
  856
  857		return e.complexity.Comment.Message(childComplexity), true
  858
  859	case "CommentConnection.edges":
  860		if e.complexity.CommentConnection.Edges == nil {
  861			break
  862		}
  863
  864		return e.complexity.CommentConnection.Edges(childComplexity), true
  865
  866	case "CommentConnection.nodes":
  867		if e.complexity.CommentConnection.Nodes == nil {
  868			break
  869		}
  870
  871		return e.complexity.CommentConnection.Nodes(childComplexity), true
  872
  873	case "CommentConnection.pageInfo":
  874		if e.complexity.CommentConnection.PageInfo == nil {
  875			break
  876		}
  877
  878		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  879
  880	case "CommentConnection.totalCount":
  881		if e.complexity.CommentConnection.TotalCount == nil {
  882			break
  883		}
  884
  885		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  886
  887	case "CommentEdge.cursor":
  888		if e.complexity.CommentEdge.Cursor == nil {
  889			break
  890		}
  891
  892		return e.complexity.CommentEdge.Cursor(childComplexity), true
  893
  894	case "CommentEdge.node":
  895		if e.complexity.CommentEdge.Node == nil {
  896			break
  897		}
  898
  899		return e.complexity.CommentEdge.Node(childComplexity), true
  900
  901	case "CommentHistoryStep.date":
  902		if e.complexity.CommentHistoryStep.Date == nil {
  903			break
  904		}
  905
  906		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  907
  908	case "CommentHistoryStep.message":
  909		if e.complexity.CommentHistoryStep.Message == nil {
  910			break
  911		}
  912
  913		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  914
  915	case "CreateOperation.author":
  916		if e.complexity.CreateOperation.Author == nil {
  917			break
  918		}
  919
  920		return e.complexity.CreateOperation.Author(childComplexity), true
  921
  922	case "CreateOperation.date":
  923		if e.complexity.CreateOperation.Date == nil {
  924			break
  925		}
  926
  927		return e.complexity.CreateOperation.Date(childComplexity), true
  928
  929	case "CreateOperation.files":
  930		if e.complexity.CreateOperation.Files == nil {
  931			break
  932		}
  933
  934		return e.complexity.CreateOperation.Files(childComplexity), true
  935
  936	case "CreateOperation.id":
  937		if e.complexity.CreateOperation.ID == nil {
  938			break
  939		}
  940
  941		return e.complexity.CreateOperation.ID(childComplexity), true
  942
  943	case "CreateOperation.message":
  944		if e.complexity.CreateOperation.Message == nil {
  945			break
  946		}
  947
  948		return e.complexity.CreateOperation.Message(childComplexity), true
  949
  950	case "CreateOperation.title":
  951		if e.complexity.CreateOperation.Title == nil {
  952			break
  953		}
  954
  955		return e.complexity.CreateOperation.Title(childComplexity), true
  956
  957	case "CreateTimelineItem.author":
  958		if e.complexity.CreateTimelineItem.Author == nil {
  959			break
  960		}
  961
  962		return e.complexity.CreateTimelineItem.Author(childComplexity), true
  963
  964	case "CreateTimelineItem.createdAt":
  965		if e.complexity.CreateTimelineItem.CreatedAt == nil {
  966			break
  967		}
  968
  969		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
  970
  971	case "CreateTimelineItem.edited":
  972		if e.complexity.CreateTimelineItem.Edited == nil {
  973			break
  974		}
  975
  976		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
  977
  978	case "CreateTimelineItem.files":
  979		if e.complexity.CreateTimelineItem.Files == nil {
  980			break
  981		}
  982
  983		return e.complexity.CreateTimelineItem.Files(childComplexity), true
  984
  985	case "CreateTimelineItem.history":
  986		if e.complexity.CreateTimelineItem.History == nil {
  987			break
  988		}
  989
  990		return e.complexity.CreateTimelineItem.History(childComplexity), true
  991
  992	case "CreateTimelineItem.id":
  993		if e.complexity.CreateTimelineItem.ID == nil {
  994			break
  995		}
  996
  997		return e.complexity.CreateTimelineItem.ID(childComplexity), true
  998
  999	case "CreateTimelineItem.lastEdit":
 1000		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1001			break
 1002		}
 1003
 1004		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1005
 1006	case "CreateTimelineItem.message":
 1007		if e.complexity.CreateTimelineItem.Message == nil {
 1008			break
 1009		}
 1010
 1011		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1012
 1013	case "CreateTimelineItem.messageIsEmpty":
 1014		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1015			break
 1016		}
 1017
 1018		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1019
 1020	case "EditCommentOperation.author":
 1021		if e.complexity.EditCommentOperation.Author == nil {
 1022			break
 1023		}
 1024
 1025		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1026
 1027	case "EditCommentOperation.date":
 1028		if e.complexity.EditCommentOperation.Date == nil {
 1029			break
 1030		}
 1031
 1032		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1033
 1034	case "EditCommentOperation.files":
 1035		if e.complexity.EditCommentOperation.Files == nil {
 1036			break
 1037		}
 1038
 1039		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1040
 1041	case "EditCommentOperation.id":
 1042		if e.complexity.EditCommentOperation.ID == nil {
 1043			break
 1044		}
 1045
 1046		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1047
 1048	case "EditCommentOperation.message":
 1049		if e.complexity.EditCommentOperation.Message == nil {
 1050			break
 1051		}
 1052
 1053		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1054
 1055	case "EditCommentOperation.target":
 1056		if e.complexity.EditCommentOperation.Target == nil {
 1057			break
 1058		}
 1059
 1060		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1061
 1062	case "Identity.avatarUrl":
 1063		if e.complexity.Identity.AvatarUrl == nil {
 1064			break
 1065		}
 1066
 1067		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1068
 1069	case "Identity.displayName":
 1070		if e.complexity.Identity.DisplayName == nil {
 1071			break
 1072		}
 1073
 1074		return e.complexity.Identity.DisplayName(childComplexity), true
 1075
 1076	case "Identity.email":
 1077		if e.complexity.Identity.Email == nil {
 1078			break
 1079		}
 1080
 1081		return e.complexity.Identity.Email(childComplexity), true
 1082
 1083	case "Identity.humanId":
 1084		if e.complexity.Identity.HumanID == nil {
 1085			break
 1086		}
 1087
 1088		return e.complexity.Identity.HumanID(childComplexity), true
 1089
 1090	case "Identity.id":
 1091		if e.complexity.Identity.ID == nil {
 1092			break
 1093		}
 1094
 1095		return e.complexity.Identity.ID(childComplexity), true
 1096
 1097	case "Identity.isProtected":
 1098		if e.complexity.Identity.IsProtected == nil {
 1099			break
 1100		}
 1101
 1102		return e.complexity.Identity.IsProtected(childComplexity), true
 1103
 1104	case "Identity.login":
 1105		if e.complexity.Identity.Login == nil {
 1106			break
 1107		}
 1108
 1109		return e.complexity.Identity.Login(childComplexity), true
 1110
 1111	case "Identity.name":
 1112		if e.complexity.Identity.Name == nil {
 1113			break
 1114		}
 1115
 1116		return e.complexity.Identity.Name(childComplexity), true
 1117
 1118	case "IdentityConnection.edges":
 1119		if e.complexity.IdentityConnection.Edges == nil {
 1120			break
 1121		}
 1122
 1123		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1124
 1125	case "IdentityConnection.nodes":
 1126		if e.complexity.IdentityConnection.Nodes == nil {
 1127			break
 1128		}
 1129
 1130		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1131
 1132	case "IdentityConnection.pageInfo":
 1133		if e.complexity.IdentityConnection.PageInfo == nil {
 1134			break
 1135		}
 1136
 1137		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1138
 1139	case "IdentityConnection.totalCount":
 1140		if e.complexity.IdentityConnection.TotalCount == nil {
 1141			break
 1142		}
 1143
 1144		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1145
 1146	case "IdentityEdge.cursor":
 1147		if e.complexity.IdentityEdge.Cursor == nil {
 1148			break
 1149		}
 1150
 1151		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1152
 1153	case "IdentityEdge.node":
 1154		if e.complexity.IdentityEdge.Node == nil {
 1155			break
 1156		}
 1157
 1158		return e.complexity.IdentityEdge.Node(childComplexity), true
 1159
 1160	case "Label.color":
 1161		if e.complexity.Label.Color == nil {
 1162			break
 1163		}
 1164
 1165		return e.complexity.Label.Color(childComplexity), true
 1166
 1167	case "Label.name":
 1168		if e.complexity.Label.Name == nil {
 1169			break
 1170		}
 1171
 1172		return e.complexity.Label.Name(childComplexity), true
 1173
 1174	case "LabelChangeOperation.added":
 1175		if e.complexity.LabelChangeOperation.Added == nil {
 1176			break
 1177		}
 1178
 1179		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1180
 1181	case "LabelChangeOperation.author":
 1182		if e.complexity.LabelChangeOperation.Author == nil {
 1183			break
 1184		}
 1185
 1186		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1187
 1188	case "LabelChangeOperation.date":
 1189		if e.complexity.LabelChangeOperation.Date == nil {
 1190			break
 1191		}
 1192
 1193		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1194
 1195	case "LabelChangeOperation.id":
 1196		if e.complexity.LabelChangeOperation.ID == nil {
 1197			break
 1198		}
 1199
 1200		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1201
 1202	case "LabelChangeOperation.removed":
 1203		if e.complexity.LabelChangeOperation.Removed == nil {
 1204			break
 1205		}
 1206
 1207		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1208
 1209	case "LabelChangeResult.label":
 1210		if e.complexity.LabelChangeResult.Label == nil {
 1211			break
 1212		}
 1213
 1214		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1215
 1216	case "LabelChangeResult.status":
 1217		if e.complexity.LabelChangeResult.Status == nil {
 1218			break
 1219		}
 1220
 1221		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1222
 1223	case "LabelChangeTimelineItem.added":
 1224		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1225			break
 1226		}
 1227
 1228		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1229
 1230	case "LabelChangeTimelineItem.author":
 1231		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1232			break
 1233		}
 1234
 1235		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1236
 1237	case "LabelChangeTimelineItem.date":
 1238		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1239			break
 1240		}
 1241
 1242		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1243
 1244	case "LabelChangeTimelineItem.id":
 1245		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1246			break
 1247		}
 1248
 1249		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1250
 1251	case "LabelChangeTimelineItem.removed":
 1252		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1253			break
 1254		}
 1255
 1256		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1257
 1258	case "LabelConnection.edges":
 1259		if e.complexity.LabelConnection.Edges == nil {
 1260			break
 1261		}
 1262
 1263		return e.complexity.LabelConnection.Edges(childComplexity), true
 1264
 1265	case "LabelConnection.nodes":
 1266		if e.complexity.LabelConnection.Nodes == nil {
 1267			break
 1268		}
 1269
 1270		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1271
 1272	case "LabelConnection.pageInfo":
 1273		if e.complexity.LabelConnection.PageInfo == nil {
 1274			break
 1275		}
 1276
 1277		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1278
 1279	case "LabelConnection.totalCount":
 1280		if e.complexity.LabelConnection.TotalCount == nil {
 1281			break
 1282		}
 1283
 1284		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1285
 1286	case "LabelEdge.cursor":
 1287		if e.complexity.LabelEdge.Cursor == nil {
 1288			break
 1289		}
 1290
 1291		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1292
 1293	case "LabelEdge.node":
 1294		if e.complexity.LabelEdge.Node == nil {
 1295			break
 1296		}
 1297
 1298		return e.complexity.LabelEdge.Node(childComplexity), true
 1299
 1300	case "Mutation.addComment":
 1301		if e.complexity.Mutation.AddComment == nil {
 1302			break
 1303		}
 1304
 1305		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1306		if err != nil {
 1307			return 0, false
 1308		}
 1309
 1310		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1311
 1312	case "Mutation.changeLabels":
 1313		if e.complexity.Mutation.ChangeLabels == nil {
 1314			break
 1315		}
 1316
 1317		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1318		if err != nil {
 1319			return 0, false
 1320		}
 1321
 1322		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1323
 1324	case "Mutation.closeBug":
 1325		if e.complexity.Mutation.CloseBug == nil {
 1326			break
 1327		}
 1328
 1329		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1330		if err != nil {
 1331			return 0, false
 1332		}
 1333
 1334		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1335
 1336	case "Mutation.newBug":
 1337		if e.complexity.Mutation.NewBug == nil {
 1338			break
 1339		}
 1340
 1341		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1342		if err != nil {
 1343			return 0, false
 1344		}
 1345
 1346		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1347
 1348	case "Mutation.openBug":
 1349		if e.complexity.Mutation.OpenBug == nil {
 1350			break
 1351		}
 1352
 1353		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1354		if err != nil {
 1355			return 0, false
 1356		}
 1357
 1358		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1359
 1360	case "Mutation.setTitle":
 1361		if e.complexity.Mutation.SetTitle == nil {
 1362			break
 1363		}
 1364
 1365		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1366		if err != nil {
 1367			return 0, false
 1368		}
 1369
 1370		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1371
 1372	case "NewBugPayload.bug":
 1373		if e.complexity.NewBugPayload.Bug == nil {
 1374			break
 1375		}
 1376
 1377		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1378
 1379	case "NewBugPayload.clientMutationId":
 1380		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1381			break
 1382		}
 1383
 1384		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1385
 1386	case "NewBugPayload.operation":
 1387		if e.complexity.NewBugPayload.Operation == nil {
 1388			break
 1389		}
 1390
 1391		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1392
 1393	case "OpenBugPayload.bug":
 1394		if e.complexity.OpenBugPayload.Bug == nil {
 1395			break
 1396		}
 1397
 1398		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1399
 1400	case "OpenBugPayload.clientMutationId":
 1401		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1402			break
 1403		}
 1404
 1405		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1406
 1407	case "OpenBugPayload.operation":
 1408		if e.complexity.OpenBugPayload.Operation == nil {
 1409			break
 1410		}
 1411
 1412		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1413
 1414	case "OperationConnection.edges":
 1415		if e.complexity.OperationConnection.Edges == nil {
 1416			break
 1417		}
 1418
 1419		return e.complexity.OperationConnection.Edges(childComplexity), true
 1420
 1421	case "OperationConnection.nodes":
 1422		if e.complexity.OperationConnection.Nodes == nil {
 1423			break
 1424		}
 1425
 1426		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1427
 1428	case "OperationConnection.pageInfo":
 1429		if e.complexity.OperationConnection.PageInfo == nil {
 1430			break
 1431		}
 1432
 1433		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1434
 1435	case "OperationConnection.totalCount":
 1436		if e.complexity.OperationConnection.TotalCount == nil {
 1437			break
 1438		}
 1439
 1440		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1441
 1442	case "OperationEdge.cursor":
 1443		if e.complexity.OperationEdge.Cursor == nil {
 1444			break
 1445		}
 1446
 1447		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1448
 1449	case "OperationEdge.node":
 1450		if e.complexity.OperationEdge.Node == nil {
 1451			break
 1452		}
 1453
 1454		return e.complexity.OperationEdge.Node(childComplexity), true
 1455
 1456	case "PageInfo.endCursor":
 1457		if e.complexity.PageInfo.EndCursor == nil {
 1458			break
 1459		}
 1460
 1461		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1462
 1463	case "PageInfo.hasNextPage":
 1464		if e.complexity.PageInfo.HasNextPage == nil {
 1465			break
 1466		}
 1467
 1468		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1469
 1470	case "PageInfo.hasPreviousPage":
 1471		if e.complexity.PageInfo.HasPreviousPage == nil {
 1472			break
 1473		}
 1474
 1475		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1476
 1477	case "PageInfo.startCursor":
 1478		if e.complexity.PageInfo.StartCursor == nil {
 1479			break
 1480		}
 1481
 1482		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1483
 1484	case "Query.repository":
 1485		if e.complexity.Query.Repository == nil {
 1486			break
 1487		}
 1488
 1489		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1490		if err != nil {
 1491			return 0, false
 1492		}
 1493
 1494		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 1495
 1496	case "Repository.allBugs":
 1497		if e.complexity.Repository.AllBugs == nil {
 1498			break
 1499		}
 1500
 1501		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1502		if err != nil {
 1503			return 0, false
 1504		}
 1505
 1506		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1507
 1508	case "Repository.allIdentities":
 1509		if e.complexity.Repository.AllIdentities == nil {
 1510			break
 1511		}
 1512
 1513		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1514		if err != nil {
 1515			return 0, false
 1516		}
 1517
 1518		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1519
 1520	case "Repository.bug":
 1521		if e.complexity.Repository.Bug == nil {
 1522			break
 1523		}
 1524
 1525		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1526		if err != nil {
 1527			return 0, false
 1528		}
 1529
 1530		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1531
 1532	case "Repository.identity":
 1533		if e.complexity.Repository.Identity == nil {
 1534			break
 1535		}
 1536
 1537		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1538		if err != nil {
 1539			return 0, false
 1540		}
 1541
 1542		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1543
 1544	case "Repository.name":
 1545		if e.complexity.Repository.Name == nil {
 1546			break
 1547		}
 1548
 1549		return e.complexity.Repository.Name(childComplexity), true
 1550
 1551	case "Repository.userIdentity":
 1552		if e.complexity.Repository.UserIdentity == nil {
 1553			break
 1554		}
 1555
 1556		return e.complexity.Repository.UserIdentity(childComplexity), true
 1557
 1558	case "Repository.validLabels":
 1559		if e.complexity.Repository.ValidLabels == nil {
 1560			break
 1561		}
 1562
 1563		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1564		if err != nil {
 1565			return 0, false
 1566		}
 1567
 1568		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1569
 1570	case "SetStatusOperation.author":
 1571		if e.complexity.SetStatusOperation.Author == nil {
 1572			break
 1573		}
 1574
 1575		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1576
 1577	case "SetStatusOperation.date":
 1578		if e.complexity.SetStatusOperation.Date == nil {
 1579			break
 1580		}
 1581
 1582		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1583
 1584	case "SetStatusOperation.id":
 1585		if e.complexity.SetStatusOperation.ID == nil {
 1586			break
 1587		}
 1588
 1589		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1590
 1591	case "SetStatusOperation.status":
 1592		if e.complexity.SetStatusOperation.Status == nil {
 1593			break
 1594		}
 1595
 1596		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1597
 1598	case "SetStatusTimelineItem.author":
 1599		if e.complexity.SetStatusTimelineItem.Author == nil {
 1600			break
 1601		}
 1602
 1603		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1604
 1605	case "SetStatusTimelineItem.date":
 1606		if e.complexity.SetStatusTimelineItem.Date == nil {
 1607			break
 1608		}
 1609
 1610		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1611
 1612	case "SetStatusTimelineItem.id":
 1613		if e.complexity.SetStatusTimelineItem.ID == nil {
 1614			break
 1615		}
 1616
 1617		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1618
 1619	case "SetStatusTimelineItem.status":
 1620		if e.complexity.SetStatusTimelineItem.Status == nil {
 1621			break
 1622		}
 1623
 1624		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1625
 1626	case "SetTitleOperation.author":
 1627		if e.complexity.SetTitleOperation.Author == nil {
 1628			break
 1629		}
 1630
 1631		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1632
 1633	case "SetTitleOperation.date":
 1634		if e.complexity.SetTitleOperation.Date == nil {
 1635			break
 1636		}
 1637
 1638		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1639
 1640	case "SetTitleOperation.id":
 1641		if e.complexity.SetTitleOperation.ID == nil {
 1642			break
 1643		}
 1644
 1645		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1646
 1647	case "SetTitleOperation.title":
 1648		if e.complexity.SetTitleOperation.Title == nil {
 1649			break
 1650		}
 1651
 1652		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1653
 1654	case "SetTitleOperation.was":
 1655		if e.complexity.SetTitleOperation.Was == nil {
 1656			break
 1657		}
 1658
 1659		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1660
 1661	case "SetTitlePayload.bug":
 1662		if e.complexity.SetTitlePayload.Bug == nil {
 1663			break
 1664		}
 1665
 1666		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1667
 1668	case "SetTitlePayload.clientMutationId":
 1669		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1670			break
 1671		}
 1672
 1673		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1674
 1675	case "SetTitlePayload.operation":
 1676		if e.complexity.SetTitlePayload.Operation == nil {
 1677			break
 1678		}
 1679
 1680		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1681
 1682	case "SetTitleTimelineItem.author":
 1683		if e.complexity.SetTitleTimelineItem.Author == nil {
 1684			break
 1685		}
 1686
 1687		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1688
 1689	case "SetTitleTimelineItem.date":
 1690		if e.complexity.SetTitleTimelineItem.Date == nil {
 1691			break
 1692		}
 1693
 1694		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1695
 1696	case "SetTitleTimelineItem.id":
 1697		if e.complexity.SetTitleTimelineItem.ID == nil {
 1698			break
 1699		}
 1700
 1701		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1702
 1703	case "SetTitleTimelineItem.title":
 1704		if e.complexity.SetTitleTimelineItem.Title == nil {
 1705			break
 1706		}
 1707
 1708		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1709
 1710	case "SetTitleTimelineItem.was":
 1711		if e.complexity.SetTitleTimelineItem.Was == nil {
 1712			break
 1713		}
 1714
 1715		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1716
 1717	case "TimelineItemConnection.edges":
 1718		if e.complexity.TimelineItemConnection.Edges == nil {
 1719			break
 1720		}
 1721
 1722		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1723
 1724	case "TimelineItemConnection.nodes":
 1725		if e.complexity.TimelineItemConnection.Nodes == nil {
 1726			break
 1727		}
 1728
 1729		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1730
 1731	case "TimelineItemConnection.pageInfo":
 1732		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1733			break
 1734		}
 1735
 1736		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1737
 1738	case "TimelineItemConnection.totalCount":
 1739		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1740			break
 1741		}
 1742
 1743		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1744
 1745	case "TimelineItemEdge.cursor":
 1746		if e.complexity.TimelineItemEdge.Cursor == nil {
 1747			break
 1748		}
 1749
 1750		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1751
 1752	case "TimelineItemEdge.node":
 1753		if e.complexity.TimelineItemEdge.Node == nil {
 1754			break
 1755		}
 1756
 1757		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1758
 1759	}
 1760	return 0, false
 1761}
 1762
 1763func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1764	rc := graphql.GetOperationContext(ctx)
 1765	ec := executionContext{rc, e}
 1766	first := true
 1767
 1768	switch rc.Operation.Operation {
 1769	case ast.Query:
 1770		return func(ctx context.Context) *graphql.Response {
 1771			if !first {
 1772				return nil
 1773			}
 1774			first = false
 1775			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1776			var buf bytes.Buffer
 1777			data.MarshalGQL(&buf)
 1778
 1779			return &graphql.Response{
 1780				Data: buf.Bytes(),
 1781			}
 1782		}
 1783	case ast.Mutation:
 1784		return func(ctx context.Context) *graphql.Response {
 1785			if !first {
 1786				return nil
 1787			}
 1788			first = false
 1789			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1790			var buf bytes.Buffer
 1791			data.MarshalGQL(&buf)
 1792
 1793			return &graphql.Response{
 1794				Data: buf.Bytes(),
 1795			}
 1796		}
 1797
 1798	default:
 1799		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1800	}
 1801}
 1802
 1803type executionContext struct {
 1804	*graphql.OperationContext
 1805	*executableSchema
 1806}
 1807
 1808func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1809	if ec.DisableIntrospection {
 1810		return nil, errors.New("introspection disabled")
 1811	}
 1812	return introspection.WrapSchema(parsedSchema), nil
 1813}
 1814
 1815func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1816	if ec.DisableIntrospection {
 1817		return nil, errors.New("introspection disabled")
 1818	}
 1819	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1820}
 1821
 1822var sources = []*ast.Source{
 1823	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1824type Comment implements Authored {
 1825  """The author of this comment."""
 1826  author: Identity!
 1827
 1828  """The message of this comment."""
 1829  message: String!
 1830
 1831  """All media's hash referenced in this comment"""
 1832  files: [Hash!]!
 1833}
 1834
 1835type CommentConnection {
 1836  edges: [CommentEdge!]!
 1837  nodes: [Comment!]!
 1838  pageInfo: PageInfo!
 1839  totalCount: Int!
 1840}
 1841
 1842type CommentEdge {
 1843  cursor: String!
 1844  node: Comment!
 1845}
 1846
 1847enum Status {
 1848  OPEN
 1849  CLOSED
 1850}
 1851
 1852type Bug implements Authored {
 1853  """The identifier for this bug"""
 1854  id: String!
 1855  """The human version (truncated) identifier for this bug"""
 1856  humanId: String!
 1857  status: Status!
 1858  title: String!
 1859  labels: [Label!]!
 1860  author: Identity!
 1861  createdAt: Time!
 1862  lastEdit: Time!
 1863
 1864  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1865  actors(
 1866    """Returns the elements in the list that come after the specified cursor."""
 1867    after: String
 1868    """Returns the elements in the list that come before the specified cursor."""
 1869    before: String
 1870    """Returns the first _n_ elements from the list."""
 1871    first: Int
 1872    """Returns the last _n_ elements from the list."""
 1873    last: Int
 1874  ): IdentityConnection!
 1875
 1876  """The participants of the bug. Participants are Identity that have created or
 1877  added a comment on the bug."""
 1878  participants(
 1879    """Returns the elements in the list that come after the specified cursor."""
 1880    after: String
 1881    """Returns the elements in the list that come before the specified cursor."""
 1882    before: String
 1883    """Returns the first _n_ elements from the list."""
 1884    first: Int
 1885    """Returns the last _n_ elements from the list."""
 1886    last: Int
 1887  ): IdentityConnection!
 1888
 1889  comments(
 1890    """Returns the elements in the list that come after the specified cursor."""
 1891    after: String
 1892    """Returns the elements in the list that come before the specified cursor."""
 1893    before: String
 1894    """Returns the first _n_ elements from the list."""
 1895    first: Int
 1896    """Returns the last _n_ elements from the list."""
 1897    last: Int
 1898  ): CommentConnection!
 1899
 1900  timeline(
 1901    """Returns the elements in the list that come after the specified cursor."""
 1902    after: String
 1903    """Returns the elements in the list that come before the specified cursor."""
 1904    before: String
 1905    """Returns the first _n_ elements from the list."""
 1906    first: Int
 1907    """Returns the last _n_ elements from the list."""
 1908    last: Int
 1909  ): TimelineItemConnection!
 1910
 1911  operations(
 1912    """Returns the elements in the list that come after the specified cursor."""
 1913    after: String
 1914    """Returns the elements in the list that come before the specified cursor."""
 1915    before: String
 1916    """Returns the first _n_ elements from the list."""
 1917    first: Int
 1918    """Returns the last _n_ elements from the list."""
 1919    last: Int
 1920  ): OperationConnection!
 1921}
 1922
 1923"""The connection type for Bug."""
 1924type BugConnection {
 1925  """A list of edges."""
 1926  edges: [BugEdge!]!
 1927  nodes: [Bug!]!
 1928  """Information to aid in pagination."""
 1929  pageInfo: PageInfo!
 1930  """Identifies the total count of items in the connection."""
 1931  totalCount: Int!
 1932}
 1933
 1934"""An edge in a connection."""
 1935type BugEdge {
 1936  """A cursor for use in pagination."""
 1937  cursor: String!
 1938  """The item at the end of the edge."""
 1939  node: Bug!
 1940}
 1941`, BuiltIn: false},
 1942	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1943type Identity {
 1944    """The identifier for this identity"""
 1945    id: String!
 1946    """The human version (truncated) identifier for this identity"""
 1947    humanId: String!
 1948    """The name of the person, if known."""
 1949    name: String
 1950    """The email of the person, if known."""
 1951    email: String
 1952    """The login of the person, if known."""
 1953    login: String
 1954    """A non-empty string to display, representing the identity, based on the non-empty values."""
 1955    displayName: String!
 1956    """An url to an avatar"""
 1957    avatarUrl: String
 1958    """isProtected is true if the chain of git commits started to be signed.
 1959    If that's the case, only signed commit with a valid key for this identity can be added."""
 1960    isProtected: Boolean!
 1961}
 1962
 1963type IdentityConnection {
 1964    edges: [IdentityEdge!]!
 1965    nodes: [Identity!]!
 1966    pageInfo: PageInfo!
 1967    totalCount: Int!
 1968}
 1969
 1970type IdentityEdge {
 1971    cursor: String!
 1972    node: Identity!
 1973}`, BuiltIn: false},
 1974	&ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
 1975type Label {
 1976    """The name of the label."""
 1977    name: String!
 1978    """Color of the label."""
 1979    color: Color!
 1980}
 1981
 1982type LabelConnection {
 1983    edges: [LabelEdge!]!
 1984    nodes: [Label!]!
 1985    pageInfo: PageInfo!
 1986    totalCount: Int!
 1987}
 1988
 1989type LabelEdge {
 1990    cursor: String!
 1991    node: Label!
 1992}`, BuiltIn: false},
 1993	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 1994    """A unique identifier for the client performing the mutation."""
 1995    clientMutationId: String
 1996    """"The name of the repository. If not set, the default repository is used."""
 1997    repoRef: String
 1998    """The title of the new bug."""
 1999    title: String!
 2000    """The first message of the new bug."""
 2001    message: String!
 2002    """The collection of file's hash required for the first message."""
 2003    files: [Hash!]
 2004}
 2005
 2006type NewBugPayload {
 2007    """A unique identifier for the client performing the mutation."""
 2008    clientMutationId: String
 2009    """The created bug."""
 2010    bug: Bug!
 2011    """The resulting operation."""
 2012    operation: CreateOperation!
 2013}
 2014
 2015input AddCommentInput {
 2016    """A unique identifier for the client performing the mutation."""
 2017    clientMutationId: String
 2018    """"The name of the repository. If not set, the default repository is used."""
 2019    repoRef: String
 2020    """The bug ID's prefix."""
 2021    prefix: String!
 2022    """The first message of the new bug."""
 2023    message: String!
 2024    """The collection of file's hash required for the first message."""
 2025    files: [Hash!]
 2026}
 2027
 2028type AddCommentPayload {
 2029    """A unique identifier for the client performing the mutation."""
 2030    clientMutationId: String
 2031    """The affected bug."""
 2032    bug: Bug!
 2033    """The resulting operation."""
 2034    operation: AddCommentOperation!
 2035}
 2036
 2037input ChangeLabelInput {
 2038    """A unique identifier for the client performing the mutation."""
 2039    clientMutationId: String
 2040    """"The name of the repository. If not set, the default repository is used."""
 2041    repoRef: String
 2042    """The bug ID's prefix."""
 2043    prefix: String!
 2044    """The list of label to add."""
 2045    added: [String!]
 2046    """The list of label to remove."""
 2047    Removed: [String!]
 2048}
 2049
 2050enum LabelChangeStatus {
 2051    ADDED
 2052    REMOVED
 2053    DUPLICATE_IN_OP
 2054    ALREADY_EXIST
 2055    DOESNT_EXIST
 2056}
 2057
 2058type LabelChangeResult {
 2059    """The source label."""
 2060    label: Label!
 2061    """The effect this label had."""
 2062    status: LabelChangeStatus!
 2063}
 2064
 2065type ChangeLabelPayload {
 2066    """A unique identifier for the client performing the mutation."""
 2067    clientMutationId: String
 2068    """The affected bug."""
 2069    bug: Bug!
 2070    """The resulting operation."""
 2071    operation: LabelChangeOperation!
 2072    """The effect each source label had."""
 2073    results: [LabelChangeResult]!
 2074}
 2075
 2076input OpenBugInput {
 2077    """A unique identifier for the client performing the mutation."""
 2078    clientMutationId: String
 2079    """"The name of the repository. If not set, the default repository is used."""
 2080    repoRef: String
 2081    """The bug ID's prefix."""
 2082    prefix: String!
 2083}
 2084
 2085type OpenBugPayload {
 2086    """A unique identifier for the client performing the mutation."""
 2087    clientMutationId: String
 2088    """The affected bug."""
 2089    bug: Bug!
 2090    """The resulting operation."""
 2091    operation: SetStatusOperation!
 2092}
 2093
 2094input CloseBugInput {
 2095    """A unique identifier for the client performing the mutation."""
 2096    clientMutationId: String
 2097    """"The name of the repository. If not set, the default repository is used."""
 2098    repoRef: String
 2099    """The bug ID's prefix."""
 2100    prefix: String!
 2101}
 2102
 2103type CloseBugPayload {
 2104    """A unique identifier for the client performing the mutation."""
 2105    clientMutationId: String
 2106    """The affected bug."""
 2107    bug: Bug!
 2108    """The resulting operation."""
 2109    operation: SetStatusOperation!
 2110}
 2111
 2112input SetTitleInput {
 2113    """A unique identifier for the client performing the mutation."""
 2114    clientMutationId: String
 2115    """"The name of the repository. If not set, the default repository is used."""
 2116    repoRef: String
 2117    """The bug ID's prefix."""
 2118    prefix: String!
 2119    """The new title."""
 2120    title: String!
 2121}
 2122
 2123type SetTitlePayload {
 2124    """A unique identifier for the client performing the mutation."""
 2125    clientMutationId: String
 2126    """The affected bug."""
 2127    bug: Bug!
 2128    """The resulting operation"""
 2129    operation: SetTitleOperation!
 2130}
 2131`, BuiltIn: false},
 2132	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2133interface Operation {
 2134    """The identifier of the operation"""
 2135    id: String!
 2136    """The operations author."""
 2137    author: Identity!
 2138    """The datetime when this operation was issued."""
 2139    date: Time!
 2140}
 2141
 2142# Connection
 2143
 2144"""The connection type for an Operation"""
 2145type OperationConnection {
 2146    edges: [OperationEdge!]!
 2147    nodes: [Operation!]!
 2148    pageInfo: PageInfo!
 2149    totalCount: Int!
 2150}
 2151
 2152"""Represent an Operation"""
 2153type OperationEdge {
 2154    cursor: String!
 2155    node: Operation!
 2156}
 2157
 2158# Operations
 2159
 2160type CreateOperation implements Operation & Authored {
 2161    """The identifier of the operation"""
 2162    id: String!
 2163    """The author of this object."""
 2164    author: Identity!
 2165    """The datetime when this operation was issued."""
 2166    date: Time!
 2167
 2168    title: String!
 2169    message: String!
 2170    files: [Hash!]!
 2171}
 2172
 2173type SetTitleOperation implements Operation & Authored {
 2174    """The identifier of the operation"""
 2175    id: String!
 2176    """The author of this object."""
 2177    author: Identity!
 2178    """The datetime when this operation was issued."""
 2179    date: Time!
 2180
 2181    title: String!
 2182    was: String!
 2183}
 2184
 2185type AddCommentOperation implements Operation & Authored {
 2186    """The identifier of the operation"""
 2187    id: String!
 2188    """The author of this object."""
 2189    author: Identity!
 2190    """The datetime when this operation was issued."""
 2191    date: Time!
 2192
 2193    message: String!
 2194    files: [Hash!]!
 2195}
 2196
 2197type EditCommentOperation implements Operation & Authored {
 2198    """The identifier of the operation"""
 2199    id: String!
 2200    """The author of this object."""
 2201    author: Identity!
 2202    """The datetime when this operation was issued."""
 2203    date: Time!
 2204
 2205    target: String!
 2206    message: String!
 2207    files: [Hash!]!
 2208}
 2209
 2210type SetStatusOperation implements Operation & Authored {
 2211    """The identifier of the operation"""
 2212    id: String!
 2213    """The author of this object."""
 2214    author: Identity!
 2215    """The datetime when this operation was issued."""
 2216    date: Time!
 2217
 2218    status: Status!
 2219}
 2220
 2221type LabelChangeOperation implements Operation & Authored {
 2222    """The identifier of the operation"""
 2223    id: String!
 2224    """The author of this object."""
 2225    author: Identity!
 2226    """The datetime when this operation was issued."""
 2227    date: Time!
 2228
 2229    added: [Label!]!
 2230    removed: [Label!]!
 2231}
 2232`, BuiltIn: false},
 2233	&ast.Source{Name: "schema/repository.graphql", Input: `
 2234type Repository {
 2235    """The name of the repository"""
 2236    name: String
 2237
 2238    """All the bugs"""
 2239    allBugs(
 2240        """Returns the elements in the list that come after the specified cursor."""
 2241        after: String
 2242        """Returns the elements in the list that come before the specified cursor."""
 2243        before: String
 2244        """Returns the first _n_ elements from the list."""
 2245        first: Int
 2246        """Returns the last _n_ elements from the list."""
 2247        last: Int
 2248        """A query to select and order bugs."""
 2249        query: String
 2250    ): BugConnection!
 2251
 2252    bug(prefix: String!): Bug
 2253
 2254    """All the identities"""
 2255    allIdentities(
 2256        """Returns the elements in the list that come after the specified cursor."""
 2257        after: String
 2258        """Returns the elements in the list that come before the specified cursor."""
 2259        before: String
 2260        """Returns the first _n_ elements from the list."""
 2261        first: Int
 2262        """Returns the last _n_ elements from the list."""
 2263        last: Int
 2264    ): IdentityConnection!
 2265
 2266    identity(prefix: String!): Identity
 2267
 2268    """The identity created or selected by the user as its own"""
 2269    userIdentity: Identity
 2270
 2271    """List of valid labels."""
 2272    validLabels(
 2273        """Returns the elements in the list that come after the specified cursor."""
 2274        after: String
 2275        """Returns the elements in the list that come before the specified cursor."""
 2276        before: String
 2277        """Returns the first _n_ elements from the list."""
 2278        first: Int
 2279        """Returns the last _n_ elements from the list."""
 2280        last: Int
 2281    ): LabelConnection!
 2282}`, BuiltIn: false},
 2283	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2284    """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
 2285    repository(ref: String): Repository
 2286}
 2287
 2288type Mutation {
 2289    """Create a new bug"""
 2290    newBug(input: NewBugInput!): NewBugPayload!
 2291    """Add a new comment to a bug"""
 2292    addComment(input: AddCommentInput!): AddCommentPayload!
 2293    """Add or remove a set of label on a bug"""
 2294    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2295    """Change a bug's status to open"""
 2296    openBug(input: OpenBugInput!): OpenBugPayload!
 2297    """Change a bug's status to closed"""
 2298    closeBug(input: CloseBugInput!): CloseBugPayload!
 2299    """Change a bug's title"""
 2300    setTitle(input: SetTitleInput!): SetTitlePayload!
 2301}
 2302`, BuiltIn: false},
 2303	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2304interface TimelineItem {
 2305    """The identifier of the source operation"""
 2306    id: String!
 2307}
 2308
 2309"""CommentHistoryStep hold one version of a message in the history"""
 2310type CommentHistoryStep {
 2311    message: String!
 2312    date: Time!
 2313}
 2314
 2315# Connection
 2316
 2317"""The connection type for TimelineItem"""
 2318type TimelineItemConnection {
 2319    edges: [TimelineItemEdge!]!
 2320    nodes: [TimelineItem!]!
 2321    pageInfo: PageInfo!
 2322    totalCount: Int!
 2323}
 2324
 2325"""Represent a TimelineItem"""
 2326type TimelineItemEdge {
 2327    cursor: String!
 2328    node: TimelineItem!
 2329}
 2330
 2331# Items
 2332
 2333"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2334type CreateTimelineItem implements TimelineItem & Authored {
 2335    """The identifier of the source operation"""
 2336    id: String!
 2337    author: Identity!
 2338    message: String!
 2339    messageIsEmpty: Boolean!
 2340    files: [Hash!]!
 2341    createdAt: Time!
 2342    lastEdit: Time!
 2343    edited: Boolean!
 2344    history: [CommentHistoryStep!]!
 2345}
 2346
 2347"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2348type AddCommentTimelineItem implements TimelineItem & Authored {
 2349    """The identifier of the source operation"""
 2350    id: String!
 2351    author: Identity!
 2352    message: String!
 2353    messageIsEmpty: Boolean!
 2354    files: [Hash!]!
 2355    createdAt: Time!
 2356    lastEdit: Time!
 2357    edited: Boolean!
 2358    history: [CommentHistoryStep!]!
 2359}
 2360
 2361"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2362type LabelChangeTimelineItem implements TimelineItem & Authored {
 2363    """The identifier of the source operation"""
 2364    id: String!
 2365    author: Identity!
 2366    date: Time!
 2367    added: [Label!]!
 2368    removed: [Label!]!
 2369}
 2370
 2371"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2372type SetStatusTimelineItem implements TimelineItem & Authored {
 2373    """The identifier of the source operation"""
 2374    id: String!
 2375    author: Identity!
 2376    date: Time!
 2377    status: Status!
 2378}
 2379
 2380"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2381type SetTitleTimelineItem implements TimelineItem & Authored {
 2382    """The identifier of the source operation"""
 2383    id: String!
 2384    author: Identity!
 2385    date: Time!
 2386    title: String!
 2387    was: String!
 2388}
 2389`, BuiltIn: false},
 2390	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2391scalar Hash
 2392
 2393"""Defines a color by red, green and blue components."""
 2394type Color {
 2395    """Red component of the color."""
 2396    R: Int!
 2397    """Green component of the color."""
 2398    G: Int!
 2399    """Blue component of the color."""
 2400    B: Int!
 2401}
 2402
 2403"""Information about pagination in a connection."""
 2404type PageInfo {
 2405    """When paginating forwards, are there more items?"""
 2406    hasNextPage: Boolean!
 2407    """When paginating backwards, are there more items?"""
 2408    hasPreviousPage: Boolean!
 2409    """When paginating backwards, the cursor to continue."""
 2410    startCursor: String!
 2411    """When paginating forwards, the cursor to continue."""
 2412    endCursor: String!
 2413}
 2414
 2415"""An object that has an author."""
 2416interface Authored {
 2417    """The author of this object."""
 2418    author: Identity!
 2419}
 2420`, BuiltIn: false},
 2421}
 2422var parsedSchema = gqlparser.MustLoadSchema(sources...)
 2423
 2424// endregion ************************** generated!.gotpl **************************
 2425
 2426// region    ***************************** args.gotpl *****************************
 2427
 2428func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2429	var err error
 2430	args := map[string]interface{}{}
 2431	var arg0 *string
 2432	if tmp, ok := rawArgs["after"]; ok {
 2433		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2434		if err != nil {
 2435			return nil, err
 2436		}
 2437	}
 2438	args["after"] = arg0
 2439	var arg1 *string
 2440	if tmp, ok := rawArgs["before"]; ok {
 2441		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2442		if err != nil {
 2443			return nil, err
 2444		}
 2445	}
 2446	args["before"] = arg1
 2447	var arg2 *int
 2448	if tmp, ok := rawArgs["first"]; ok {
 2449		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2450		if err != nil {
 2451			return nil, err
 2452		}
 2453	}
 2454	args["first"] = arg2
 2455	var arg3 *int
 2456	if tmp, ok := rawArgs["last"]; ok {
 2457		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2458		if err != nil {
 2459			return nil, err
 2460		}
 2461	}
 2462	args["last"] = arg3
 2463	return args, nil
 2464}
 2465
 2466func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2467	var err error
 2468	args := map[string]interface{}{}
 2469	var arg0 *string
 2470	if tmp, ok := rawArgs["after"]; ok {
 2471		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2472		if err != nil {
 2473			return nil, err
 2474		}
 2475	}
 2476	args["after"] = arg0
 2477	var arg1 *string
 2478	if tmp, ok := rawArgs["before"]; ok {
 2479		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2480		if err != nil {
 2481			return nil, err
 2482		}
 2483	}
 2484	args["before"] = arg1
 2485	var arg2 *int
 2486	if tmp, ok := rawArgs["first"]; ok {
 2487		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2488		if err != nil {
 2489			return nil, err
 2490		}
 2491	}
 2492	args["first"] = arg2
 2493	var arg3 *int
 2494	if tmp, ok := rawArgs["last"]; ok {
 2495		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2496		if err != nil {
 2497			return nil, err
 2498		}
 2499	}
 2500	args["last"] = arg3
 2501	return args, nil
 2502}
 2503
 2504func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2505	var err error
 2506	args := map[string]interface{}{}
 2507	var arg0 *string
 2508	if tmp, ok := rawArgs["after"]; ok {
 2509		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2510		if err != nil {
 2511			return nil, err
 2512		}
 2513	}
 2514	args["after"] = arg0
 2515	var arg1 *string
 2516	if tmp, ok := rawArgs["before"]; ok {
 2517		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2518		if err != nil {
 2519			return nil, err
 2520		}
 2521	}
 2522	args["before"] = arg1
 2523	var arg2 *int
 2524	if tmp, ok := rawArgs["first"]; ok {
 2525		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2526		if err != nil {
 2527			return nil, err
 2528		}
 2529	}
 2530	args["first"] = arg2
 2531	var arg3 *int
 2532	if tmp, ok := rawArgs["last"]; ok {
 2533		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2534		if err != nil {
 2535			return nil, err
 2536		}
 2537	}
 2538	args["last"] = arg3
 2539	return args, nil
 2540}
 2541
 2542func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2543	var err error
 2544	args := map[string]interface{}{}
 2545	var arg0 *string
 2546	if tmp, ok := rawArgs["after"]; ok {
 2547		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2548		if err != nil {
 2549			return nil, err
 2550		}
 2551	}
 2552	args["after"] = arg0
 2553	var arg1 *string
 2554	if tmp, ok := rawArgs["before"]; ok {
 2555		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2556		if err != nil {
 2557			return nil, err
 2558		}
 2559	}
 2560	args["before"] = arg1
 2561	var arg2 *int
 2562	if tmp, ok := rawArgs["first"]; ok {
 2563		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2564		if err != nil {
 2565			return nil, err
 2566		}
 2567	}
 2568	args["first"] = arg2
 2569	var arg3 *int
 2570	if tmp, ok := rawArgs["last"]; ok {
 2571		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2572		if err != nil {
 2573			return nil, err
 2574		}
 2575	}
 2576	args["last"] = arg3
 2577	return args, nil
 2578}
 2579
 2580func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2581	var err error
 2582	args := map[string]interface{}{}
 2583	var arg0 *string
 2584	if tmp, ok := rawArgs["after"]; ok {
 2585		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2586		if err != nil {
 2587			return nil, err
 2588		}
 2589	}
 2590	args["after"] = arg0
 2591	var arg1 *string
 2592	if tmp, ok := rawArgs["before"]; ok {
 2593		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2594		if err != nil {
 2595			return nil, err
 2596		}
 2597	}
 2598	args["before"] = arg1
 2599	var arg2 *int
 2600	if tmp, ok := rawArgs["first"]; ok {
 2601		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2602		if err != nil {
 2603			return nil, err
 2604		}
 2605	}
 2606	args["first"] = arg2
 2607	var arg3 *int
 2608	if tmp, ok := rawArgs["last"]; ok {
 2609		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2610		if err != nil {
 2611			return nil, err
 2612		}
 2613	}
 2614	args["last"] = arg3
 2615	return args, nil
 2616}
 2617
 2618func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2619	var err error
 2620	args := map[string]interface{}{}
 2621	var arg0 models.AddCommentInput
 2622	if tmp, ok := rawArgs["input"]; ok {
 2623		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2624		if err != nil {
 2625			return nil, err
 2626		}
 2627	}
 2628	args["input"] = arg0
 2629	return args, nil
 2630}
 2631
 2632func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2633	var err error
 2634	args := map[string]interface{}{}
 2635	var arg0 *models.ChangeLabelInput
 2636	if tmp, ok := rawArgs["input"]; ok {
 2637		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2638		if err != nil {
 2639			return nil, err
 2640		}
 2641	}
 2642	args["input"] = arg0
 2643	return args, nil
 2644}
 2645
 2646func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2647	var err error
 2648	args := map[string]interface{}{}
 2649	var arg0 models.CloseBugInput
 2650	if tmp, ok := rawArgs["input"]; ok {
 2651		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2652		if err != nil {
 2653			return nil, err
 2654		}
 2655	}
 2656	args["input"] = arg0
 2657	return args, nil
 2658}
 2659
 2660func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2661	var err error
 2662	args := map[string]interface{}{}
 2663	var arg0 models.NewBugInput
 2664	if tmp, ok := rawArgs["input"]; ok {
 2665		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2666		if err != nil {
 2667			return nil, err
 2668		}
 2669	}
 2670	args["input"] = arg0
 2671	return args, nil
 2672}
 2673
 2674func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2675	var err error
 2676	args := map[string]interface{}{}
 2677	var arg0 models.OpenBugInput
 2678	if tmp, ok := rawArgs["input"]; ok {
 2679		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2680		if err != nil {
 2681			return nil, err
 2682		}
 2683	}
 2684	args["input"] = arg0
 2685	return args, nil
 2686}
 2687
 2688func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2689	var err error
 2690	args := map[string]interface{}{}
 2691	var arg0 models.SetTitleInput
 2692	if tmp, ok := rawArgs["input"]; ok {
 2693		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2694		if err != nil {
 2695			return nil, err
 2696		}
 2697	}
 2698	args["input"] = arg0
 2699	return args, nil
 2700}
 2701
 2702func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2703	var err error
 2704	args := map[string]interface{}{}
 2705	var arg0 string
 2706	if tmp, ok := rawArgs["name"]; ok {
 2707		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2708		if err != nil {
 2709			return nil, err
 2710		}
 2711	}
 2712	args["name"] = arg0
 2713	return args, nil
 2714}
 2715
 2716func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2717	var err error
 2718	args := map[string]interface{}{}
 2719	var arg0 *string
 2720	if tmp, ok := rawArgs["ref"]; ok {
 2721		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2722		if err != nil {
 2723			return nil, err
 2724		}
 2725	}
 2726	args["ref"] = arg0
 2727	return args, nil
 2728}
 2729
 2730func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2731	var err error
 2732	args := map[string]interface{}{}
 2733	var arg0 *string
 2734	if tmp, ok := rawArgs["after"]; ok {
 2735		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2736		if err != nil {
 2737			return nil, err
 2738		}
 2739	}
 2740	args["after"] = arg0
 2741	var arg1 *string
 2742	if tmp, ok := rawArgs["before"]; ok {
 2743		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2744		if err != nil {
 2745			return nil, err
 2746		}
 2747	}
 2748	args["before"] = arg1
 2749	var arg2 *int
 2750	if tmp, ok := rawArgs["first"]; ok {
 2751		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2752		if err != nil {
 2753			return nil, err
 2754		}
 2755	}
 2756	args["first"] = arg2
 2757	var arg3 *int
 2758	if tmp, ok := rawArgs["last"]; ok {
 2759		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2760		if err != nil {
 2761			return nil, err
 2762		}
 2763	}
 2764	args["last"] = arg3
 2765	var arg4 *string
 2766	if tmp, ok := rawArgs["query"]; ok {
 2767		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2768		if err != nil {
 2769			return nil, err
 2770		}
 2771	}
 2772	args["query"] = arg4
 2773	return args, nil
 2774}
 2775
 2776func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2777	var err error
 2778	args := map[string]interface{}{}
 2779	var arg0 *string
 2780	if tmp, ok := rawArgs["after"]; ok {
 2781		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2782		if err != nil {
 2783			return nil, err
 2784		}
 2785	}
 2786	args["after"] = arg0
 2787	var arg1 *string
 2788	if tmp, ok := rawArgs["before"]; ok {
 2789		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2790		if err != nil {
 2791			return nil, err
 2792		}
 2793	}
 2794	args["before"] = arg1
 2795	var arg2 *int
 2796	if tmp, ok := rawArgs["first"]; ok {
 2797		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2798		if err != nil {
 2799			return nil, err
 2800		}
 2801	}
 2802	args["first"] = arg2
 2803	var arg3 *int
 2804	if tmp, ok := rawArgs["last"]; ok {
 2805		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2806		if err != nil {
 2807			return nil, err
 2808		}
 2809	}
 2810	args["last"] = arg3
 2811	return args, nil
 2812}
 2813
 2814func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2815	var err error
 2816	args := map[string]interface{}{}
 2817	var arg0 string
 2818	if tmp, ok := rawArgs["prefix"]; ok {
 2819		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2820		if err != nil {
 2821			return nil, err
 2822		}
 2823	}
 2824	args["prefix"] = arg0
 2825	return args, nil
 2826}
 2827
 2828func (ec *executionContext) field_Repository_identity_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["prefix"]; ok {
 2833		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2834		if err != nil {
 2835			return nil, err
 2836		}
 2837	}
 2838	args["prefix"] = arg0
 2839	return args, nil
 2840}
 2841
 2842func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2843	var err error
 2844	args := map[string]interface{}{}
 2845	var arg0 *string
 2846	if tmp, ok := rawArgs["after"]; ok {
 2847		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2848		if err != nil {
 2849			return nil, err
 2850		}
 2851	}
 2852	args["after"] = arg0
 2853	var arg1 *string
 2854	if tmp, ok := rawArgs["before"]; ok {
 2855		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2856		if err != nil {
 2857			return nil, err
 2858		}
 2859	}
 2860	args["before"] = arg1
 2861	var arg2 *int
 2862	if tmp, ok := rawArgs["first"]; ok {
 2863		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2864		if err != nil {
 2865			return nil, err
 2866		}
 2867	}
 2868	args["first"] = arg2
 2869	var arg3 *int
 2870	if tmp, ok := rawArgs["last"]; ok {
 2871		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2872		if err != nil {
 2873			return nil, err
 2874		}
 2875	}
 2876	args["last"] = arg3
 2877	return args, nil
 2878}
 2879
 2880func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2881	var err error
 2882	args := map[string]interface{}{}
 2883	var arg0 bool
 2884	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2885		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2886		if err != nil {
 2887			return nil, err
 2888		}
 2889	}
 2890	args["includeDeprecated"] = arg0
 2891	return args, nil
 2892}
 2893
 2894func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2895	var err error
 2896	args := map[string]interface{}{}
 2897	var arg0 bool
 2898	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2899		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2900		if err != nil {
 2901			return nil, err
 2902		}
 2903	}
 2904	args["includeDeprecated"] = arg0
 2905	return args, nil
 2906}
 2907
 2908// endregion ***************************** args.gotpl *****************************
 2909
 2910// region    ************************** directives.gotpl **************************
 2911
 2912// endregion ************************** directives.gotpl **************************
 2913
 2914// region    **************************** field.gotpl *****************************
 2915
 2916func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2917	defer func() {
 2918		if r := recover(); r != nil {
 2919			ec.Error(ctx, ec.Recover(ctx, r))
 2920			ret = graphql.Null
 2921		}
 2922	}()
 2923	fc := &graphql.FieldContext{
 2924		Object:   "AddCommentOperation",
 2925		Field:    field,
 2926		Args:     nil,
 2927		IsMethod: true,
 2928	}
 2929
 2930	ctx = graphql.WithFieldContext(ctx, fc)
 2931	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2932		ctx = rctx // use context from middleware stack in children
 2933		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 2934	})
 2935	if err != nil {
 2936		ec.Error(ctx, err)
 2937		return graphql.Null
 2938	}
 2939	if resTmp == nil {
 2940		if !graphql.HasFieldError(ctx, fc) {
 2941			ec.Errorf(ctx, "must not be null")
 2942		}
 2943		return graphql.Null
 2944	}
 2945	res := resTmp.(string)
 2946	fc.Result = res
 2947	return ec.marshalNString2string(ctx, field.Selections, res)
 2948}
 2949
 2950func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2951	defer func() {
 2952		if r := recover(); r != nil {
 2953			ec.Error(ctx, ec.Recover(ctx, r))
 2954			ret = graphql.Null
 2955		}
 2956	}()
 2957	fc := &graphql.FieldContext{
 2958		Object:   "AddCommentOperation",
 2959		Field:    field,
 2960		Args:     nil,
 2961		IsMethod: true,
 2962	}
 2963
 2964	ctx = graphql.WithFieldContext(ctx, fc)
 2965	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2966		ctx = rctx // use context from middleware stack in children
 2967		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
 2968	})
 2969	if err != nil {
 2970		ec.Error(ctx, err)
 2971		return graphql.Null
 2972	}
 2973	if resTmp == nil {
 2974		if !graphql.HasFieldError(ctx, fc) {
 2975			ec.Errorf(ctx, "must not be null")
 2976		}
 2977		return graphql.Null
 2978	}
 2979	res := resTmp.(models.IdentityWrapper)
 2980	fc.Result = res
 2981	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 2982}
 2983
 2984func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2985	defer func() {
 2986		if r := recover(); r != nil {
 2987			ec.Error(ctx, ec.Recover(ctx, r))
 2988			ret = graphql.Null
 2989		}
 2990	}()
 2991	fc := &graphql.FieldContext{
 2992		Object:   "AddCommentOperation",
 2993		Field:    field,
 2994		Args:     nil,
 2995		IsMethod: true,
 2996	}
 2997
 2998	ctx = graphql.WithFieldContext(ctx, fc)
 2999	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3000		ctx = rctx // use context from middleware stack in children
 3001		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 3002	})
 3003	if err != nil {
 3004		ec.Error(ctx, err)
 3005		return graphql.Null
 3006	}
 3007	if resTmp == nil {
 3008		if !graphql.HasFieldError(ctx, fc) {
 3009			ec.Errorf(ctx, "must not be null")
 3010		}
 3011		return graphql.Null
 3012	}
 3013	res := resTmp.(*time.Time)
 3014	fc.Result = res
 3015	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3016}
 3017
 3018func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3019	defer func() {
 3020		if r := recover(); r != nil {
 3021			ec.Error(ctx, ec.Recover(ctx, r))
 3022			ret = graphql.Null
 3023		}
 3024	}()
 3025	fc := &graphql.FieldContext{
 3026		Object:   "AddCommentOperation",
 3027		Field:    field,
 3028		Args:     nil,
 3029		IsMethod: false,
 3030	}
 3031
 3032	ctx = graphql.WithFieldContext(ctx, fc)
 3033	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3034		ctx = rctx // use context from middleware stack in children
 3035		return obj.Message, nil
 3036	})
 3037	if err != nil {
 3038		ec.Error(ctx, err)
 3039		return graphql.Null
 3040	}
 3041	if resTmp == nil {
 3042		if !graphql.HasFieldError(ctx, fc) {
 3043			ec.Errorf(ctx, "must not be null")
 3044		}
 3045		return graphql.Null
 3046	}
 3047	res := resTmp.(string)
 3048	fc.Result = res
 3049	return ec.marshalNString2string(ctx, field.Selections, res)
 3050}
 3051
 3052func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3053	defer func() {
 3054		if r := recover(); r != nil {
 3055			ec.Error(ctx, ec.Recover(ctx, r))
 3056			ret = graphql.Null
 3057		}
 3058	}()
 3059	fc := &graphql.FieldContext{
 3060		Object:   "AddCommentOperation",
 3061		Field:    field,
 3062		Args:     nil,
 3063		IsMethod: false,
 3064	}
 3065
 3066	ctx = graphql.WithFieldContext(ctx, fc)
 3067	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3068		ctx = rctx // use context from middleware stack in children
 3069		return obj.Files, nil
 3070	})
 3071	if err != nil {
 3072		ec.Error(ctx, err)
 3073		return graphql.Null
 3074	}
 3075	if resTmp == nil {
 3076		if !graphql.HasFieldError(ctx, fc) {
 3077			ec.Errorf(ctx, "must not be null")
 3078		}
 3079		return graphql.Null
 3080	}
 3081	res := resTmp.([]git.Hash)
 3082	fc.Result = res
 3083	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3084}
 3085
 3086func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3087	defer func() {
 3088		if r := recover(); r != nil {
 3089			ec.Error(ctx, ec.Recover(ctx, r))
 3090			ret = graphql.Null
 3091		}
 3092	}()
 3093	fc := &graphql.FieldContext{
 3094		Object:   "AddCommentPayload",
 3095		Field:    field,
 3096		Args:     nil,
 3097		IsMethod: false,
 3098	}
 3099
 3100	ctx = graphql.WithFieldContext(ctx, fc)
 3101	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3102		ctx = rctx // use context from middleware stack in children
 3103		return obj.ClientMutationID, nil
 3104	})
 3105	if err != nil {
 3106		ec.Error(ctx, err)
 3107		return graphql.Null
 3108	}
 3109	if resTmp == nil {
 3110		return graphql.Null
 3111	}
 3112	res := resTmp.(*string)
 3113	fc.Result = res
 3114	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3115}
 3116
 3117func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3118	defer func() {
 3119		if r := recover(); r != nil {
 3120			ec.Error(ctx, ec.Recover(ctx, r))
 3121			ret = graphql.Null
 3122		}
 3123	}()
 3124	fc := &graphql.FieldContext{
 3125		Object:   "AddCommentPayload",
 3126		Field:    field,
 3127		Args:     nil,
 3128		IsMethod: false,
 3129	}
 3130
 3131	ctx = graphql.WithFieldContext(ctx, fc)
 3132	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3133		ctx = rctx // use context from middleware stack in children
 3134		return obj.Bug, nil
 3135	})
 3136	if err != nil {
 3137		ec.Error(ctx, err)
 3138		return graphql.Null
 3139	}
 3140	if resTmp == nil {
 3141		if !graphql.HasFieldError(ctx, fc) {
 3142			ec.Errorf(ctx, "must not be null")
 3143		}
 3144		return graphql.Null
 3145	}
 3146	res := resTmp.(models.BugWrapper)
 3147	fc.Result = res
 3148	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 3149}
 3150
 3151func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3152	defer func() {
 3153		if r := recover(); r != nil {
 3154			ec.Error(ctx, ec.Recover(ctx, r))
 3155			ret = graphql.Null
 3156		}
 3157	}()
 3158	fc := &graphql.FieldContext{
 3159		Object:   "AddCommentPayload",
 3160		Field:    field,
 3161		Args:     nil,
 3162		IsMethod: false,
 3163	}
 3164
 3165	ctx = graphql.WithFieldContext(ctx, fc)
 3166	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3167		ctx = rctx // use context from middleware stack in children
 3168		return obj.Operation, nil
 3169	})
 3170	if err != nil {
 3171		ec.Error(ctx, err)
 3172		return graphql.Null
 3173	}
 3174	if resTmp == nil {
 3175		if !graphql.HasFieldError(ctx, fc) {
 3176			ec.Errorf(ctx, "must not be null")
 3177		}
 3178		return graphql.Null
 3179	}
 3180	res := resTmp.(*bug.AddCommentOperation)
 3181	fc.Result = res
 3182	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3183}
 3184
 3185func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3186	defer func() {
 3187		if r := recover(); r != nil {
 3188			ec.Error(ctx, ec.Recover(ctx, r))
 3189			ret = graphql.Null
 3190		}
 3191	}()
 3192	fc := &graphql.FieldContext{
 3193		Object:   "AddCommentTimelineItem",
 3194		Field:    field,
 3195		Args:     nil,
 3196		IsMethod: true,
 3197	}
 3198
 3199	ctx = graphql.WithFieldContext(ctx, fc)
 3200	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3201		ctx = rctx // use context from middleware stack in children
 3202		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3203	})
 3204	if err != nil {
 3205		ec.Error(ctx, err)
 3206		return graphql.Null
 3207	}
 3208	if resTmp == nil {
 3209		if !graphql.HasFieldError(ctx, fc) {
 3210			ec.Errorf(ctx, "must not be null")
 3211		}
 3212		return graphql.Null
 3213	}
 3214	res := resTmp.(string)
 3215	fc.Result = res
 3216	return ec.marshalNString2string(ctx, field.Selections, res)
 3217}
 3218
 3219func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3220	defer func() {
 3221		if r := recover(); r != nil {
 3222			ec.Error(ctx, ec.Recover(ctx, r))
 3223			ret = graphql.Null
 3224		}
 3225	}()
 3226	fc := &graphql.FieldContext{
 3227		Object:   "AddCommentTimelineItem",
 3228		Field:    field,
 3229		Args:     nil,
 3230		IsMethod: true,
 3231	}
 3232
 3233	ctx = graphql.WithFieldContext(ctx, fc)
 3234	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3235		ctx = rctx // use context from middleware stack in children
 3236		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
 3237	})
 3238	if err != nil {
 3239		ec.Error(ctx, err)
 3240		return graphql.Null
 3241	}
 3242	if resTmp == nil {
 3243		if !graphql.HasFieldError(ctx, fc) {
 3244			ec.Errorf(ctx, "must not be null")
 3245		}
 3246		return graphql.Null
 3247	}
 3248	res := resTmp.(models.IdentityWrapper)
 3249	fc.Result = res
 3250	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3251}
 3252
 3253func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3254	defer func() {
 3255		if r := recover(); r != nil {
 3256			ec.Error(ctx, ec.Recover(ctx, r))
 3257			ret = graphql.Null
 3258		}
 3259	}()
 3260	fc := &graphql.FieldContext{
 3261		Object:   "AddCommentTimelineItem",
 3262		Field:    field,
 3263		Args:     nil,
 3264		IsMethod: false,
 3265	}
 3266
 3267	ctx = graphql.WithFieldContext(ctx, fc)
 3268	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3269		ctx = rctx // use context from middleware stack in children
 3270		return obj.Message, nil
 3271	})
 3272	if err != nil {
 3273		ec.Error(ctx, err)
 3274		return graphql.Null
 3275	}
 3276	if resTmp == nil {
 3277		if !graphql.HasFieldError(ctx, fc) {
 3278			ec.Errorf(ctx, "must not be null")
 3279		}
 3280		return graphql.Null
 3281	}
 3282	res := resTmp.(string)
 3283	fc.Result = res
 3284	return ec.marshalNString2string(ctx, field.Selections, res)
 3285}
 3286
 3287func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3288	defer func() {
 3289		if r := recover(); r != nil {
 3290			ec.Error(ctx, ec.Recover(ctx, r))
 3291			ret = graphql.Null
 3292		}
 3293	}()
 3294	fc := &graphql.FieldContext{
 3295		Object:   "AddCommentTimelineItem",
 3296		Field:    field,
 3297		Args:     nil,
 3298		IsMethod: true,
 3299	}
 3300
 3301	ctx = graphql.WithFieldContext(ctx, fc)
 3302	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3303		ctx = rctx // use context from middleware stack in children
 3304		return obj.MessageIsEmpty(), nil
 3305	})
 3306	if err != nil {
 3307		ec.Error(ctx, err)
 3308		return graphql.Null
 3309	}
 3310	if resTmp == nil {
 3311		if !graphql.HasFieldError(ctx, fc) {
 3312			ec.Errorf(ctx, "must not be null")
 3313		}
 3314		return graphql.Null
 3315	}
 3316	res := resTmp.(bool)
 3317	fc.Result = res
 3318	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3319}
 3320
 3321func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3322	defer func() {
 3323		if r := recover(); r != nil {
 3324			ec.Error(ctx, ec.Recover(ctx, r))
 3325			ret = graphql.Null
 3326		}
 3327	}()
 3328	fc := &graphql.FieldContext{
 3329		Object:   "AddCommentTimelineItem",
 3330		Field:    field,
 3331		Args:     nil,
 3332		IsMethod: false,
 3333	}
 3334
 3335	ctx = graphql.WithFieldContext(ctx, fc)
 3336	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3337		ctx = rctx // use context from middleware stack in children
 3338		return obj.Files, nil
 3339	})
 3340	if err != nil {
 3341		ec.Error(ctx, err)
 3342		return graphql.Null
 3343	}
 3344	if resTmp == nil {
 3345		if !graphql.HasFieldError(ctx, fc) {
 3346			ec.Errorf(ctx, "must not be null")
 3347		}
 3348		return graphql.Null
 3349	}
 3350	res := resTmp.([]git.Hash)
 3351	fc.Result = res
 3352	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3353}
 3354
 3355func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3356	defer func() {
 3357		if r := recover(); r != nil {
 3358			ec.Error(ctx, ec.Recover(ctx, r))
 3359			ret = graphql.Null
 3360		}
 3361	}()
 3362	fc := &graphql.FieldContext{
 3363		Object:   "AddCommentTimelineItem",
 3364		Field:    field,
 3365		Args:     nil,
 3366		IsMethod: true,
 3367	}
 3368
 3369	ctx = graphql.WithFieldContext(ctx, fc)
 3370	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3371		ctx = rctx // use context from middleware stack in children
 3372		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3373	})
 3374	if err != nil {
 3375		ec.Error(ctx, err)
 3376		return graphql.Null
 3377	}
 3378	if resTmp == nil {
 3379		if !graphql.HasFieldError(ctx, fc) {
 3380			ec.Errorf(ctx, "must not be null")
 3381		}
 3382		return graphql.Null
 3383	}
 3384	res := resTmp.(*time.Time)
 3385	fc.Result = res
 3386	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3387}
 3388
 3389func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3390	defer func() {
 3391		if r := recover(); r != nil {
 3392			ec.Error(ctx, ec.Recover(ctx, r))
 3393			ret = graphql.Null
 3394		}
 3395	}()
 3396	fc := &graphql.FieldContext{
 3397		Object:   "AddCommentTimelineItem",
 3398		Field:    field,
 3399		Args:     nil,
 3400		IsMethod: true,
 3401	}
 3402
 3403	ctx = graphql.WithFieldContext(ctx, fc)
 3404	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3405		ctx = rctx // use context from middleware stack in children
 3406		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3407	})
 3408	if err != nil {
 3409		ec.Error(ctx, err)
 3410		return graphql.Null
 3411	}
 3412	if resTmp == nil {
 3413		if !graphql.HasFieldError(ctx, fc) {
 3414			ec.Errorf(ctx, "must not be null")
 3415		}
 3416		return graphql.Null
 3417	}
 3418	res := resTmp.(*time.Time)
 3419	fc.Result = res
 3420	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3421}
 3422
 3423func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3424	defer func() {
 3425		if r := recover(); r != nil {
 3426			ec.Error(ctx, ec.Recover(ctx, r))
 3427			ret = graphql.Null
 3428		}
 3429	}()
 3430	fc := &graphql.FieldContext{
 3431		Object:   "AddCommentTimelineItem",
 3432		Field:    field,
 3433		Args:     nil,
 3434		IsMethod: true,
 3435	}
 3436
 3437	ctx = graphql.WithFieldContext(ctx, fc)
 3438	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3439		ctx = rctx // use context from middleware stack in children
 3440		return obj.Edited(), nil
 3441	})
 3442	if err != nil {
 3443		ec.Error(ctx, err)
 3444		return graphql.Null
 3445	}
 3446	if resTmp == nil {
 3447		if !graphql.HasFieldError(ctx, fc) {
 3448			ec.Errorf(ctx, "must not be null")
 3449		}
 3450		return graphql.Null
 3451	}
 3452	res := resTmp.(bool)
 3453	fc.Result = res
 3454	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3455}
 3456
 3457func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3458	defer func() {
 3459		if r := recover(); r != nil {
 3460			ec.Error(ctx, ec.Recover(ctx, r))
 3461			ret = graphql.Null
 3462		}
 3463	}()
 3464	fc := &graphql.FieldContext{
 3465		Object:   "AddCommentTimelineItem",
 3466		Field:    field,
 3467		Args:     nil,
 3468		IsMethod: false,
 3469	}
 3470
 3471	ctx = graphql.WithFieldContext(ctx, fc)
 3472	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3473		ctx = rctx // use context from middleware stack in children
 3474		return obj.History, nil
 3475	})
 3476	if err != nil {
 3477		ec.Error(ctx, err)
 3478		return graphql.Null
 3479	}
 3480	if resTmp == nil {
 3481		if !graphql.HasFieldError(ctx, fc) {
 3482			ec.Errorf(ctx, "must not be null")
 3483		}
 3484		return graphql.Null
 3485	}
 3486	res := resTmp.([]bug.CommentHistoryStep)
 3487	fc.Result = res
 3488	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3489}
 3490
 3491func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3492	defer func() {
 3493		if r := recover(); r != nil {
 3494			ec.Error(ctx, ec.Recover(ctx, r))
 3495			ret = graphql.Null
 3496		}
 3497	}()
 3498	fc := &graphql.FieldContext{
 3499		Object:   "Bug",
 3500		Field:    field,
 3501		Args:     nil,
 3502		IsMethod: true,
 3503	}
 3504
 3505	ctx = graphql.WithFieldContext(ctx, fc)
 3506	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3507		ctx = rctx // use context from middleware stack in children
 3508		return ec.resolvers.Bug().ID(rctx, obj)
 3509	})
 3510	if err != nil {
 3511		ec.Error(ctx, err)
 3512		return graphql.Null
 3513	}
 3514	if resTmp == nil {
 3515		if !graphql.HasFieldError(ctx, fc) {
 3516			ec.Errorf(ctx, "must not be null")
 3517		}
 3518		return graphql.Null
 3519	}
 3520	res := resTmp.(string)
 3521	fc.Result = res
 3522	return ec.marshalNString2string(ctx, field.Selections, res)
 3523}
 3524
 3525func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3526	defer func() {
 3527		if r := recover(); r != nil {
 3528			ec.Error(ctx, ec.Recover(ctx, r))
 3529			ret = graphql.Null
 3530		}
 3531	}()
 3532	fc := &graphql.FieldContext{
 3533		Object:   "Bug",
 3534		Field:    field,
 3535		Args:     nil,
 3536		IsMethod: true,
 3537	}
 3538
 3539	ctx = graphql.WithFieldContext(ctx, fc)
 3540	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3541		ctx = rctx // use context from middleware stack in children
 3542		return ec.resolvers.Bug().HumanID(rctx, obj)
 3543	})
 3544	if err != nil {
 3545		ec.Error(ctx, err)
 3546		return graphql.Null
 3547	}
 3548	if resTmp == nil {
 3549		if !graphql.HasFieldError(ctx, fc) {
 3550			ec.Errorf(ctx, "must not be null")
 3551		}
 3552		return graphql.Null
 3553	}
 3554	res := resTmp.(string)
 3555	fc.Result = res
 3556	return ec.marshalNString2string(ctx, field.Selections, res)
 3557}
 3558
 3559func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3560	defer func() {
 3561		if r := recover(); r != nil {
 3562			ec.Error(ctx, ec.Recover(ctx, r))
 3563			ret = graphql.Null
 3564		}
 3565	}()
 3566	fc := &graphql.FieldContext{
 3567		Object:   "Bug",
 3568		Field:    field,
 3569		Args:     nil,
 3570		IsMethod: true,
 3571	}
 3572
 3573	ctx = graphql.WithFieldContext(ctx, fc)
 3574	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3575		ctx = rctx // use context from middleware stack in children
 3576		return ec.resolvers.Bug().Status(rctx, obj)
 3577	})
 3578	if err != nil {
 3579		ec.Error(ctx, err)
 3580		return graphql.Null
 3581	}
 3582	if resTmp == nil {
 3583		if !graphql.HasFieldError(ctx, fc) {
 3584			ec.Errorf(ctx, "must not be null")
 3585		}
 3586		return graphql.Null
 3587	}
 3588	res := resTmp.(models.Status)
 3589	fc.Result = res
 3590	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3591}
 3592
 3593func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3594	defer func() {
 3595		if r := recover(); r != nil {
 3596			ec.Error(ctx, ec.Recover(ctx, r))
 3597			ret = graphql.Null
 3598		}
 3599	}()
 3600	fc := &graphql.FieldContext{
 3601		Object:   "Bug",
 3602		Field:    field,
 3603		Args:     nil,
 3604		IsMethod: true,
 3605	}
 3606
 3607	ctx = graphql.WithFieldContext(ctx, fc)
 3608	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3609		ctx = rctx // use context from middleware stack in children
 3610		return obj.Title(), nil
 3611	})
 3612	if err != nil {
 3613		ec.Error(ctx, err)
 3614		return graphql.Null
 3615	}
 3616	if resTmp == nil {
 3617		if !graphql.HasFieldError(ctx, fc) {
 3618			ec.Errorf(ctx, "must not be null")
 3619		}
 3620		return graphql.Null
 3621	}
 3622	res := resTmp.(string)
 3623	fc.Result = res
 3624	return ec.marshalNString2string(ctx, field.Selections, res)
 3625}
 3626
 3627func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3628	defer func() {
 3629		if r := recover(); r != nil {
 3630			ec.Error(ctx, ec.Recover(ctx, r))
 3631			ret = graphql.Null
 3632		}
 3633	}()
 3634	fc := &graphql.FieldContext{
 3635		Object:   "Bug",
 3636		Field:    field,
 3637		Args:     nil,
 3638		IsMethod: true,
 3639	}
 3640
 3641	ctx = graphql.WithFieldContext(ctx, fc)
 3642	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3643		ctx = rctx // use context from middleware stack in children
 3644		return obj.Labels(), nil
 3645	})
 3646	if err != nil {
 3647		ec.Error(ctx, err)
 3648		return graphql.Null
 3649	}
 3650	if resTmp == nil {
 3651		if !graphql.HasFieldError(ctx, fc) {
 3652			ec.Errorf(ctx, "must not be null")
 3653		}
 3654		return graphql.Null
 3655	}
 3656	res := resTmp.([]bug.Label)
 3657	fc.Result = res
 3658	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 3659}
 3660
 3661func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3662	defer func() {
 3663		if r := recover(); r != nil {
 3664			ec.Error(ctx, ec.Recover(ctx, r))
 3665			ret = graphql.Null
 3666		}
 3667	}()
 3668	fc := &graphql.FieldContext{
 3669		Object:   "Bug",
 3670		Field:    field,
 3671		Args:     nil,
 3672		IsMethod: true,
 3673	}
 3674
 3675	ctx = graphql.WithFieldContext(ctx, fc)
 3676	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3677		ctx = rctx // use context from middleware stack in children
 3678		return obj.Author()
 3679	})
 3680	if err != nil {
 3681		ec.Error(ctx, err)
 3682		return graphql.Null
 3683	}
 3684	if resTmp == nil {
 3685		if !graphql.HasFieldError(ctx, fc) {
 3686			ec.Errorf(ctx, "must not be null")
 3687		}
 3688		return graphql.Null
 3689	}
 3690	res := resTmp.(models.IdentityWrapper)
 3691	fc.Result = res
 3692	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3693}
 3694
 3695func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3696	defer func() {
 3697		if r := recover(); r != nil {
 3698			ec.Error(ctx, ec.Recover(ctx, r))
 3699			ret = graphql.Null
 3700		}
 3701	}()
 3702	fc := &graphql.FieldContext{
 3703		Object:   "Bug",
 3704		Field:    field,
 3705		Args:     nil,
 3706		IsMethod: true,
 3707	}
 3708
 3709	ctx = graphql.WithFieldContext(ctx, fc)
 3710	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3711		ctx = rctx // use context from middleware stack in children
 3712		return obj.CreatedAt(), nil
 3713	})
 3714	if err != nil {
 3715		ec.Error(ctx, err)
 3716		return graphql.Null
 3717	}
 3718	if resTmp == nil {
 3719		if !graphql.HasFieldError(ctx, fc) {
 3720			ec.Errorf(ctx, "must not be null")
 3721		}
 3722		return graphql.Null
 3723	}
 3724	res := resTmp.(time.Time)
 3725	fc.Result = res
 3726	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3727}
 3728
 3729func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3730	defer func() {
 3731		if r := recover(); r != nil {
 3732			ec.Error(ctx, ec.Recover(ctx, r))
 3733			ret = graphql.Null
 3734		}
 3735	}()
 3736	fc := &graphql.FieldContext{
 3737		Object:   "Bug",
 3738		Field:    field,
 3739		Args:     nil,
 3740		IsMethod: true,
 3741	}
 3742
 3743	ctx = graphql.WithFieldContext(ctx, fc)
 3744	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3745		ctx = rctx // use context from middleware stack in children
 3746		return obj.LastEdit(), nil
 3747	})
 3748	if err != nil {
 3749		ec.Error(ctx, err)
 3750		return graphql.Null
 3751	}
 3752	if resTmp == nil {
 3753		if !graphql.HasFieldError(ctx, fc) {
 3754			ec.Errorf(ctx, "must not be null")
 3755		}
 3756		return graphql.Null
 3757	}
 3758	res := resTmp.(time.Time)
 3759	fc.Result = res
 3760	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3761}
 3762
 3763func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3764	defer func() {
 3765		if r := recover(); r != nil {
 3766			ec.Error(ctx, ec.Recover(ctx, r))
 3767			ret = graphql.Null
 3768		}
 3769	}()
 3770	fc := &graphql.FieldContext{
 3771		Object:   "Bug",
 3772		Field:    field,
 3773		Args:     nil,
 3774		IsMethod: true,
 3775	}
 3776
 3777	ctx = graphql.WithFieldContext(ctx, fc)
 3778	rawArgs := field.ArgumentMap(ec.Variables)
 3779	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3780	if err != nil {
 3781		ec.Error(ctx, err)
 3782		return graphql.Null
 3783	}
 3784	fc.Args = args
 3785	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3786		ctx = rctx // use context from middleware stack in children
 3787		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3788	})
 3789	if err != nil {
 3790		ec.Error(ctx, err)
 3791		return graphql.Null
 3792	}
 3793	if resTmp == nil {
 3794		if !graphql.HasFieldError(ctx, fc) {
 3795			ec.Errorf(ctx, "must not be null")
 3796		}
 3797		return graphql.Null
 3798	}
 3799	res := resTmp.(*models.IdentityConnection)
 3800	fc.Result = res
 3801	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3802}
 3803
 3804func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3805	defer func() {
 3806		if r := recover(); r != nil {
 3807			ec.Error(ctx, ec.Recover(ctx, r))
 3808			ret = graphql.Null
 3809		}
 3810	}()
 3811	fc := &graphql.FieldContext{
 3812		Object:   "Bug",
 3813		Field:    field,
 3814		Args:     nil,
 3815		IsMethod: true,
 3816	}
 3817
 3818	ctx = graphql.WithFieldContext(ctx, fc)
 3819	rawArgs := field.ArgumentMap(ec.Variables)
 3820	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3821	if err != nil {
 3822		ec.Error(ctx, err)
 3823		return graphql.Null
 3824	}
 3825	fc.Args = args
 3826	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3827		ctx = rctx // use context from middleware stack in children
 3828		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3829	})
 3830	if err != nil {
 3831		ec.Error(ctx, err)
 3832		return graphql.Null
 3833	}
 3834	if resTmp == nil {
 3835		if !graphql.HasFieldError(ctx, fc) {
 3836			ec.Errorf(ctx, "must not be null")
 3837		}
 3838		return graphql.Null
 3839	}
 3840	res := resTmp.(*models.IdentityConnection)
 3841	fc.Result = res
 3842	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3843}
 3844
 3845func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3846	defer func() {
 3847		if r := recover(); r != nil {
 3848			ec.Error(ctx, ec.Recover(ctx, r))
 3849			ret = graphql.Null
 3850		}
 3851	}()
 3852	fc := &graphql.FieldContext{
 3853		Object:   "Bug",
 3854		Field:    field,
 3855		Args:     nil,
 3856		IsMethod: true,
 3857	}
 3858
 3859	ctx = graphql.WithFieldContext(ctx, fc)
 3860	rawArgs := field.ArgumentMap(ec.Variables)
 3861	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3862	if err != nil {
 3863		ec.Error(ctx, err)
 3864		return graphql.Null
 3865	}
 3866	fc.Args = args
 3867	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3868		ctx = rctx // use context from middleware stack in children
 3869		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3870	})
 3871	if err != nil {
 3872		ec.Error(ctx, err)
 3873		return graphql.Null
 3874	}
 3875	if resTmp == nil {
 3876		if !graphql.HasFieldError(ctx, fc) {
 3877			ec.Errorf(ctx, "must not be null")
 3878		}
 3879		return graphql.Null
 3880	}
 3881	res := resTmp.(*models.CommentConnection)
 3882	fc.Result = res
 3883	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3884}
 3885
 3886func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3887	defer func() {
 3888		if r := recover(); r != nil {
 3889			ec.Error(ctx, ec.Recover(ctx, r))
 3890			ret = graphql.Null
 3891		}
 3892	}()
 3893	fc := &graphql.FieldContext{
 3894		Object:   "Bug",
 3895		Field:    field,
 3896		Args:     nil,
 3897		IsMethod: true,
 3898	}
 3899
 3900	ctx = graphql.WithFieldContext(ctx, fc)
 3901	rawArgs := field.ArgumentMap(ec.Variables)
 3902	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3903	if err != nil {
 3904		ec.Error(ctx, err)
 3905		return graphql.Null
 3906	}
 3907	fc.Args = args
 3908	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3909		ctx = rctx // use context from middleware stack in children
 3910		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3911	})
 3912	if err != nil {
 3913		ec.Error(ctx, err)
 3914		return graphql.Null
 3915	}
 3916	if resTmp == nil {
 3917		if !graphql.HasFieldError(ctx, fc) {
 3918			ec.Errorf(ctx, "must not be null")
 3919		}
 3920		return graphql.Null
 3921	}
 3922	res := resTmp.(*models.TimelineItemConnection)
 3923	fc.Result = res
 3924	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 3925}
 3926
 3927func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3928	defer func() {
 3929		if r := recover(); r != nil {
 3930			ec.Error(ctx, ec.Recover(ctx, r))
 3931			ret = graphql.Null
 3932		}
 3933	}()
 3934	fc := &graphql.FieldContext{
 3935		Object:   "Bug",
 3936		Field:    field,
 3937		Args:     nil,
 3938		IsMethod: true,
 3939	}
 3940
 3941	ctx = graphql.WithFieldContext(ctx, fc)
 3942	rawArgs := field.ArgumentMap(ec.Variables)
 3943	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 3944	if err != nil {
 3945		ec.Error(ctx, err)
 3946		return graphql.Null
 3947	}
 3948	fc.Args = args
 3949	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3950		ctx = rctx // use context from middleware stack in children
 3951		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3952	})
 3953	if err != nil {
 3954		ec.Error(ctx, err)
 3955		return graphql.Null
 3956	}
 3957	if resTmp == nil {
 3958		if !graphql.HasFieldError(ctx, fc) {
 3959			ec.Errorf(ctx, "must not be null")
 3960		}
 3961		return graphql.Null
 3962	}
 3963	res := resTmp.(*models.OperationConnection)
 3964	fc.Result = res
 3965	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 3966}
 3967
 3968func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 3969	defer func() {
 3970		if r := recover(); r != nil {
 3971			ec.Error(ctx, ec.Recover(ctx, r))
 3972			ret = graphql.Null
 3973		}
 3974	}()
 3975	fc := &graphql.FieldContext{
 3976		Object:   "BugConnection",
 3977		Field:    field,
 3978		Args:     nil,
 3979		IsMethod: false,
 3980	}
 3981
 3982	ctx = graphql.WithFieldContext(ctx, fc)
 3983	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3984		ctx = rctx // use context from middleware stack in children
 3985		return obj.Edges, nil
 3986	})
 3987	if err != nil {
 3988		ec.Error(ctx, err)
 3989		return graphql.Null
 3990	}
 3991	if resTmp == nil {
 3992		if !graphql.HasFieldError(ctx, fc) {
 3993			ec.Errorf(ctx, "must not be null")
 3994		}
 3995		return graphql.Null
 3996	}
 3997	res := resTmp.([]*models.BugEdge)
 3998	fc.Result = res
 3999	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 4000}
 4001
 4002func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4003	defer func() {
 4004		if r := recover(); r != nil {
 4005			ec.Error(ctx, ec.Recover(ctx, r))
 4006			ret = graphql.Null
 4007		}
 4008	}()
 4009	fc := &graphql.FieldContext{
 4010		Object:   "BugConnection",
 4011		Field:    field,
 4012		Args:     nil,
 4013		IsMethod: false,
 4014	}
 4015
 4016	ctx = graphql.WithFieldContext(ctx, fc)
 4017	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4018		ctx = rctx // use context from middleware stack in children
 4019		return obj.Nodes, nil
 4020	})
 4021	if err != nil {
 4022		ec.Error(ctx, err)
 4023		return graphql.Null
 4024	}
 4025	if resTmp == nil {
 4026		if !graphql.HasFieldError(ctx, fc) {
 4027			ec.Errorf(ctx, "must not be null")
 4028		}
 4029		return graphql.Null
 4030	}
 4031	res := resTmp.([]models.BugWrapper)
 4032	fc.Result = res
 4033	return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
 4034}
 4035
 4036func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4037	defer func() {
 4038		if r := recover(); r != nil {
 4039			ec.Error(ctx, ec.Recover(ctx, r))
 4040			ret = graphql.Null
 4041		}
 4042	}()
 4043	fc := &graphql.FieldContext{
 4044		Object:   "BugConnection",
 4045		Field:    field,
 4046		Args:     nil,
 4047		IsMethod: false,
 4048	}
 4049
 4050	ctx = graphql.WithFieldContext(ctx, fc)
 4051	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4052		ctx = rctx // use context from middleware stack in children
 4053		return obj.PageInfo, nil
 4054	})
 4055	if err != nil {
 4056		ec.Error(ctx, err)
 4057		return graphql.Null
 4058	}
 4059	if resTmp == nil {
 4060		if !graphql.HasFieldError(ctx, fc) {
 4061			ec.Errorf(ctx, "must not be null")
 4062		}
 4063		return graphql.Null
 4064	}
 4065	res := resTmp.(*models.PageInfo)
 4066	fc.Result = res
 4067	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4068}
 4069
 4070func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4071	defer func() {
 4072		if r := recover(); r != nil {
 4073			ec.Error(ctx, ec.Recover(ctx, r))
 4074			ret = graphql.Null
 4075		}
 4076	}()
 4077	fc := &graphql.FieldContext{
 4078		Object:   "BugConnection",
 4079		Field:    field,
 4080		Args:     nil,
 4081		IsMethod: false,
 4082	}
 4083
 4084	ctx = graphql.WithFieldContext(ctx, fc)
 4085	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4086		ctx = rctx // use context from middleware stack in children
 4087		return obj.TotalCount, nil
 4088	})
 4089	if err != nil {
 4090		ec.Error(ctx, err)
 4091		return graphql.Null
 4092	}
 4093	if resTmp == nil {
 4094		if !graphql.HasFieldError(ctx, fc) {
 4095			ec.Errorf(ctx, "must not be null")
 4096		}
 4097		return graphql.Null
 4098	}
 4099	res := resTmp.(int)
 4100	fc.Result = res
 4101	return ec.marshalNInt2int(ctx, field.Selections, res)
 4102}
 4103
 4104func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4105	defer func() {
 4106		if r := recover(); r != nil {
 4107			ec.Error(ctx, ec.Recover(ctx, r))
 4108			ret = graphql.Null
 4109		}
 4110	}()
 4111	fc := &graphql.FieldContext{
 4112		Object:   "BugEdge",
 4113		Field:    field,
 4114		Args:     nil,
 4115		IsMethod: false,
 4116	}
 4117
 4118	ctx = graphql.WithFieldContext(ctx, fc)
 4119	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4120		ctx = rctx // use context from middleware stack in children
 4121		return obj.Cursor, nil
 4122	})
 4123	if err != nil {
 4124		ec.Error(ctx, err)
 4125		return graphql.Null
 4126	}
 4127	if resTmp == nil {
 4128		if !graphql.HasFieldError(ctx, fc) {
 4129			ec.Errorf(ctx, "must not be null")
 4130		}
 4131		return graphql.Null
 4132	}
 4133	res := resTmp.(string)
 4134	fc.Result = res
 4135	return ec.marshalNString2string(ctx, field.Selections, res)
 4136}
 4137
 4138func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4139	defer func() {
 4140		if r := recover(); r != nil {
 4141			ec.Error(ctx, ec.Recover(ctx, r))
 4142			ret = graphql.Null
 4143		}
 4144	}()
 4145	fc := &graphql.FieldContext{
 4146		Object:   "BugEdge",
 4147		Field:    field,
 4148		Args:     nil,
 4149		IsMethod: false,
 4150	}
 4151
 4152	ctx = graphql.WithFieldContext(ctx, fc)
 4153	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4154		ctx = rctx // use context from middleware stack in children
 4155		return obj.Node, nil
 4156	})
 4157	if err != nil {
 4158		ec.Error(ctx, err)
 4159		return graphql.Null
 4160	}
 4161	if resTmp == nil {
 4162		if !graphql.HasFieldError(ctx, fc) {
 4163			ec.Errorf(ctx, "must not be null")
 4164		}
 4165		return graphql.Null
 4166	}
 4167	res := resTmp.(models.BugWrapper)
 4168	fc.Result = res
 4169	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4170}
 4171
 4172func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4173	defer func() {
 4174		if r := recover(); r != nil {
 4175			ec.Error(ctx, ec.Recover(ctx, r))
 4176			ret = graphql.Null
 4177		}
 4178	}()
 4179	fc := &graphql.FieldContext{
 4180		Object:   "ChangeLabelPayload",
 4181		Field:    field,
 4182		Args:     nil,
 4183		IsMethod: false,
 4184	}
 4185
 4186	ctx = graphql.WithFieldContext(ctx, fc)
 4187	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4188		ctx = rctx // use context from middleware stack in children
 4189		return obj.ClientMutationID, nil
 4190	})
 4191	if err != nil {
 4192		ec.Error(ctx, err)
 4193		return graphql.Null
 4194	}
 4195	if resTmp == nil {
 4196		return graphql.Null
 4197	}
 4198	res := resTmp.(*string)
 4199	fc.Result = res
 4200	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4201}
 4202
 4203func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4204	defer func() {
 4205		if r := recover(); r != nil {
 4206			ec.Error(ctx, ec.Recover(ctx, r))
 4207			ret = graphql.Null
 4208		}
 4209	}()
 4210	fc := &graphql.FieldContext{
 4211		Object:   "ChangeLabelPayload",
 4212		Field:    field,
 4213		Args:     nil,
 4214		IsMethod: false,
 4215	}
 4216
 4217	ctx = graphql.WithFieldContext(ctx, fc)
 4218	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4219		ctx = rctx // use context from middleware stack in children
 4220		return obj.Bug, nil
 4221	})
 4222	if err != nil {
 4223		ec.Error(ctx, err)
 4224		return graphql.Null
 4225	}
 4226	if resTmp == nil {
 4227		if !graphql.HasFieldError(ctx, fc) {
 4228			ec.Errorf(ctx, "must not be null")
 4229		}
 4230		return graphql.Null
 4231	}
 4232	res := resTmp.(models.BugWrapper)
 4233	fc.Result = res
 4234	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4235}
 4236
 4237func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4238	defer func() {
 4239		if r := recover(); r != nil {
 4240			ec.Error(ctx, ec.Recover(ctx, r))
 4241			ret = graphql.Null
 4242		}
 4243	}()
 4244	fc := &graphql.FieldContext{
 4245		Object:   "ChangeLabelPayload",
 4246		Field:    field,
 4247		Args:     nil,
 4248		IsMethod: false,
 4249	}
 4250
 4251	ctx = graphql.WithFieldContext(ctx, fc)
 4252	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4253		ctx = rctx // use context from middleware stack in children
 4254		return obj.Operation, nil
 4255	})
 4256	if err != nil {
 4257		ec.Error(ctx, err)
 4258		return graphql.Null
 4259	}
 4260	if resTmp == nil {
 4261		if !graphql.HasFieldError(ctx, fc) {
 4262			ec.Errorf(ctx, "must not be null")
 4263		}
 4264		return graphql.Null
 4265	}
 4266	res := resTmp.(*bug.LabelChangeOperation)
 4267	fc.Result = res
 4268	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4269}
 4270
 4271func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4272	defer func() {
 4273		if r := recover(); r != nil {
 4274			ec.Error(ctx, ec.Recover(ctx, r))
 4275			ret = graphql.Null
 4276		}
 4277	}()
 4278	fc := &graphql.FieldContext{
 4279		Object:   "ChangeLabelPayload",
 4280		Field:    field,
 4281		Args:     nil,
 4282		IsMethod: false,
 4283	}
 4284
 4285	ctx = graphql.WithFieldContext(ctx, fc)
 4286	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4287		ctx = rctx // use context from middleware stack in children
 4288		return obj.Results, nil
 4289	})
 4290	if err != nil {
 4291		ec.Error(ctx, err)
 4292		return graphql.Null
 4293	}
 4294	if resTmp == nil {
 4295		if !graphql.HasFieldError(ctx, fc) {
 4296			ec.Errorf(ctx, "must not be null")
 4297		}
 4298		return graphql.Null
 4299	}
 4300	res := resTmp.([]*bug.LabelChangeResult)
 4301	fc.Result = res
 4302	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4303}
 4304
 4305func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4306	defer func() {
 4307		if r := recover(); r != nil {
 4308			ec.Error(ctx, ec.Recover(ctx, r))
 4309			ret = graphql.Null
 4310		}
 4311	}()
 4312	fc := &graphql.FieldContext{
 4313		Object:   "CloseBugPayload",
 4314		Field:    field,
 4315		Args:     nil,
 4316		IsMethod: false,
 4317	}
 4318
 4319	ctx = graphql.WithFieldContext(ctx, fc)
 4320	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4321		ctx = rctx // use context from middleware stack in children
 4322		return obj.ClientMutationID, nil
 4323	})
 4324	if err != nil {
 4325		ec.Error(ctx, err)
 4326		return graphql.Null
 4327	}
 4328	if resTmp == nil {
 4329		return graphql.Null
 4330	}
 4331	res := resTmp.(*string)
 4332	fc.Result = res
 4333	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4334}
 4335
 4336func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4337	defer func() {
 4338		if r := recover(); r != nil {
 4339			ec.Error(ctx, ec.Recover(ctx, r))
 4340			ret = graphql.Null
 4341		}
 4342	}()
 4343	fc := &graphql.FieldContext{
 4344		Object:   "CloseBugPayload",
 4345		Field:    field,
 4346		Args:     nil,
 4347		IsMethod: false,
 4348	}
 4349
 4350	ctx = graphql.WithFieldContext(ctx, fc)
 4351	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4352		ctx = rctx // use context from middleware stack in children
 4353		return obj.Bug, nil
 4354	})
 4355	if err != nil {
 4356		ec.Error(ctx, err)
 4357		return graphql.Null
 4358	}
 4359	if resTmp == nil {
 4360		if !graphql.HasFieldError(ctx, fc) {
 4361			ec.Errorf(ctx, "must not be null")
 4362		}
 4363		return graphql.Null
 4364	}
 4365	res := resTmp.(models.BugWrapper)
 4366	fc.Result = res
 4367	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4368}
 4369
 4370func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4371	defer func() {
 4372		if r := recover(); r != nil {
 4373			ec.Error(ctx, ec.Recover(ctx, r))
 4374			ret = graphql.Null
 4375		}
 4376	}()
 4377	fc := &graphql.FieldContext{
 4378		Object:   "CloseBugPayload",
 4379		Field:    field,
 4380		Args:     nil,
 4381		IsMethod: false,
 4382	}
 4383
 4384	ctx = graphql.WithFieldContext(ctx, fc)
 4385	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4386		ctx = rctx // use context from middleware stack in children
 4387		return obj.Operation, nil
 4388	})
 4389	if err != nil {
 4390		ec.Error(ctx, err)
 4391		return graphql.Null
 4392	}
 4393	if resTmp == nil {
 4394		if !graphql.HasFieldError(ctx, fc) {
 4395			ec.Errorf(ctx, "must not be null")
 4396		}
 4397		return graphql.Null
 4398	}
 4399	res := resTmp.(*bug.SetStatusOperation)
 4400	fc.Result = res
 4401	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4402}
 4403
 4404func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4405	defer func() {
 4406		if r := recover(); r != nil {
 4407			ec.Error(ctx, ec.Recover(ctx, r))
 4408			ret = graphql.Null
 4409		}
 4410	}()
 4411	fc := &graphql.FieldContext{
 4412		Object:   "Color",
 4413		Field:    field,
 4414		Args:     nil,
 4415		IsMethod: true,
 4416	}
 4417
 4418	ctx = graphql.WithFieldContext(ctx, fc)
 4419	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4420		ctx = rctx // use context from middleware stack in children
 4421		return ec.resolvers.Color().R(rctx, obj)
 4422	})
 4423	if err != nil {
 4424		ec.Error(ctx, err)
 4425		return graphql.Null
 4426	}
 4427	if resTmp == nil {
 4428		if !graphql.HasFieldError(ctx, fc) {
 4429			ec.Errorf(ctx, "must not be null")
 4430		}
 4431		return graphql.Null
 4432	}
 4433	res := resTmp.(int)
 4434	fc.Result = res
 4435	return ec.marshalNInt2int(ctx, field.Selections, res)
 4436}
 4437
 4438func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4439	defer func() {
 4440		if r := recover(); r != nil {
 4441			ec.Error(ctx, ec.Recover(ctx, r))
 4442			ret = graphql.Null
 4443		}
 4444	}()
 4445	fc := &graphql.FieldContext{
 4446		Object:   "Color",
 4447		Field:    field,
 4448		Args:     nil,
 4449		IsMethod: true,
 4450	}
 4451
 4452	ctx = graphql.WithFieldContext(ctx, fc)
 4453	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4454		ctx = rctx // use context from middleware stack in children
 4455		return ec.resolvers.Color().G(rctx, obj)
 4456	})
 4457	if err != nil {
 4458		ec.Error(ctx, err)
 4459		return graphql.Null
 4460	}
 4461	if resTmp == nil {
 4462		if !graphql.HasFieldError(ctx, fc) {
 4463			ec.Errorf(ctx, "must not be null")
 4464		}
 4465		return graphql.Null
 4466	}
 4467	res := resTmp.(int)
 4468	fc.Result = res
 4469	return ec.marshalNInt2int(ctx, field.Selections, res)
 4470}
 4471
 4472func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4473	defer func() {
 4474		if r := recover(); r != nil {
 4475			ec.Error(ctx, ec.Recover(ctx, r))
 4476			ret = graphql.Null
 4477		}
 4478	}()
 4479	fc := &graphql.FieldContext{
 4480		Object:   "Color",
 4481		Field:    field,
 4482		Args:     nil,
 4483		IsMethod: true,
 4484	}
 4485
 4486	ctx = graphql.WithFieldContext(ctx, fc)
 4487	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4488		ctx = rctx // use context from middleware stack in children
 4489		return ec.resolvers.Color().B(rctx, obj)
 4490	})
 4491	if err != nil {
 4492		ec.Error(ctx, err)
 4493		return graphql.Null
 4494	}
 4495	if resTmp == nil {
 4496		if !graphql.HasFieldError(ctx, fc) {
 4497			ec.Errorf(ctx, "must not be null")
 4498		}
 4499		return graphql.Null
 4500	}
 4501	res := resTmp.(int)
 4502	fc.Result = res
 4503	return ec.marshalNInt2int(ctx, field.Selections, res)
 4504}
 4505
 4506func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4507	defer func() {
 4508		if r := recover(); r != nil {
 4509			ec.Error(ctx, ec.Recover(ctx, r))
 4510			ret = graphql.Null
 4511		}
 4512	}()
 4513	fc := &graphql.FieldContext{
 4514		Object:   "Comment",
 4515		Field:    field,
 4516		Args:     nil,
 4517		IsMethod: true,
 4518	}
 4519
 4520	ctx = graphql.WithFieldContext(ctx, fc)
 4521	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4522		ctx = rctx // use context from middleware stack in children
 4523		return ec.resolvers.Comment().Author(rctx, obj)
 4524	})
 4525	if err != nil {
 4526		ec.Error(ctx, err)
 4527		return graphql.Null
 4528	}
 4529	if resTmp == nil {
 4530		if !graphql.HasFieldError(ctx, fc) {
 4531			ec.Errorf(ctx, "must not be null")
 4532		}
 4533		return graphql.Null
 4534	}
 4535	res := resTmp.(models.IdentityWrapper)
 4536	fc.Result = res
 4537	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4538}
 4539
 4540func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4541	defer func() {
 4542		if r := recover(); r != nil {
 4543			ec.Error(ctx, ec.Recover(ctx, r))
 4544			ret = graphql.Null
 4545		}
 4546	}()
 4547	fc := &graphql.FieldContext{
 4548		Object:   "Comment",
 4549		Field:    field,
 4550		Args:     nil,
 4551		IsMethod: false,
 4552	}
 4553
 4554	ctx = graphql.WithFieldContext(ctx, fc)
 4555	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4556		ctx = rctx // use context from middleware stack in children
 4557		return obj.Message, nil
 4558	})
 4559	if err != nil {
 4560		ec.Error(ctx, err)
 4561		return graphql.Null
 4562	}
 4563	if resTmp == nil {
 4564		if !graphql.HasFieldError(ctx, fc) {
 4565			ec.Errorf(ctx, "must not be null")
 4566		}
 4567		return graphql.Null
 4568	}
 4569	res := resTmp.(string)
 4570	fc.Result = res
 4571	return ec.marshalNString2string(ctx, field.Selections, res)
 4572}
 4573
 4574func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4575	defer func() {
 4576		if r := recover(); r != nil {
 4577			ec.Error(ctx, ec.Recover(ctx, r))
 4578			ret = graphql.Null
 4579		}
 4580	}()
 4581	fc := &graphql.FieldContext{
 4582		Object:   "Comment",
 4583		Field:    field,
 4584		Args:     nil,
 4585		IsMethod: false,
 4586	}
 4587
 4588	ctx = graphql.WithFieldContext(ctx, fc)
 4589	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4590		ctx = rctx // use context from middleware stack in children
 4591		return obj.Files, nil
 4592	})
 4593	if err != nil {
 4594		ec.Error(ctx, err)
 4595		return graphql.Null
 4596	}
 4597	if resTmp == nil {
 4598		if !graphql.HasFieldError(ctx, fc) {
 4599			ec.Errorf(ctx, "must not be null")
 4600		}
 4601		return graphql.Null
 4602	}
 4603	res := resTmp.([]git.Hash)
 4604	fc.Result = res
 4605	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 4606}
 4607
 4608func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4609	defer func() {
 4610		if r := recover(); r != nil {
 4611			ec.Error(ctx, ec.Recover(ctx, r))
 4612			ret = graphql.Null
 4613		}
 4614	}()
 4615	fc := &graphql.FieldContext{
 4616		Object:   "CommentConnection",
 4617		Field:    field,
 4618		Args:     nil,
 4619		IsMethod: false,
 4620	}
 4621
 4622	ctx = graphql.WithFieldContext(ctx, fc)
 4623	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4624		ctx = rctx // use context from middleware stack in children
 4625		return obj.Edges, nil
 4626	})
 4627	if err != nil {
 4628		ec.Error(ctx, err)
 4629		return graphql.Null
 4630	}
 4631	if resTmp == nil {
 4632		if !graphql.HasFieldError(ctx, fc) {
 4633			ec.Errorf(ctx, "must not be null")
 4634		}
 4635		return graphql.Null
 4636	}
 4637	res := resTmp.([]*models.CommentEdge)
 4638	fc.Result = res
 4639	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4640}
 4641
 4642func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4643	defer func() {
 4644		if r := recover(); r != nil {
 4645			ec.Error(ctx, ec.Recover(ctx, r))
 4646			ret = graphql.Null
 4647		}
 4648	}()
 4649	fc := &graphql.FieldContext{
 4650		Object:   "CommentConnection",
 4651		Field:    field,
 4652		Args:     nil,
 4653		IsMethod: false,
 4654	}
 4655
 4656	ctx = graphql.WithFieldContext(ctx, fc)
 4657	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4658		ctx = rctx // use context from middleware stack in children
 4659		return obj.Nodes, nil
 4660	})
 4661	if err != nil {
 4662		ec.Error(ctx, err)
 4663		return graphql.Null
 4664	}
 4665	if resTmp == nil {
 4666		if !graphql.HasFieldError(ctx, fc) {
 4667			ec.Errorf(ctx, "must not be null")
 4668		}
 4669		return graphql.Null
 4670	}
 4671	res := resTmp.([]*bug.Comment)
 4672	fc.Result = res
 4673	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 4674}
 4675
 4676func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4677	defer func() {
 4678		if r := recover(); r != nil {
 4679			ec.Error(ctx, ec.Recover(ctx, r))
 4680			ret = graphql.Null
 4681		}
 4682	}()
 4683	fc := &graphql.FieldContext{
 4684		Object:   "CommentConnection",
 4685		Field:    field,
 4686		Args:     nil,
 4687		IsMethod: false,
 4688	}
 4689
 4690	ctx = graphql.WithFieldContext(ctx, fc)
 4691	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4692		ctx = rctx // use context from middleware stack in children
 4693		return obj.PageInfo, nil
 4694	})
 4695	if err != nil {
 4696		ec.Error(ctx, err)
 4697		return graphql.Null
 4698	}
 4699	if resTmp == nil {
 4700		if !graphql.HasFieldError(ctx, fc) {
 4701			ec.Errorf(ctx, "must not be null")
 4702		}
 4703		return graphql.Null
 4704	}
 4705	res := resTmp.(*models.PageInfo)
 4706	fc.Result = res
 4707	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4708}
 4709
 4710func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4711	defer func() {
 4712		if r := recover(); r != nil {
 4713			ec.Error(ctx, ec.Recover(ctx, r))
 4714			ret = graphql.Null
 4715		}
 4716	}()
 4717	fc := &graphql.FieldContext{
 4718		Object:   "CommentConnection",
 4719		Field:    field,
 4720		Args:     nil,
 4721		IsMethod: false,
 4722	}
 4723
 4724	ctx = graphql.WithFieldContext(ctx, fc)
 4725	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4726		ctx = rctx // use context from middleware stack in children
 4727		return obj.TotalCount, nil
 4728	})
 4729	if err != nil {
 4730		ec.Error(ctx, err)
 4731		return graphql.Null
 4732	}
 4733	if resTmp == nil {
 4734		if !graphql.HasFieldError(ctx, fc) {
 4735			ec.Errorf(ctx, "must not be null")
 4736		}
 4737		return graphql.Null
 4738	}
 4739	res := resTmp.(int)
 4740	fc.Result = res
 4741	return ec.marshalNInt2int(ctx, field.Selections, res)
 4742}
 4743
 4744func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4745	defer func() {
 4746		if r := recover(); r != nil {
 4747			ec.Error(ctx, ec.Recover(ctx, r))
 4748			ret = graphql.Null
 4749		}
 4750	}()
 4751	fc := &graphql.FieldContext{
 4752		Object:   "CommentEdge",
 4753		Field:    field,
 4754		Args:     nil,
 4755		IsMethod: false,
 4756	}
 4757
 4758	ctx = graphql.WithFieldContext(ctx, fc)
 4759	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4760		ctx = rctx // use context from middleware stack in children
 4761		return obj.Cursor, nil
 4762	})
 4763	if err != nil {
 4764		ec.Error(ctx, err)
 4765		return graphql.Null
 4766	}
 4767	if resTmp == nil {
 4768		if !graphql.HasFieldError(ctx, fc) {
 4769			ec.Errorf(ctx, "must not be null")
 4770		}
 4771		return graphql.Null
 4772	}
 4773	res := resTmp.(string)
 4774	fc.Result = res
 4775	return ec.marshalNString2string(ctx, field.Selections, res)
 4776}
 4777
 4778func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4779	defer func() {
 4780		if r := recover(); r != nil {
 4781			ec.Error(ctx, ec.Recover(ctx, r))
 4782			ret = graphql.Null
 4783		}
 4784	}()
 4785	fc := &graphql.FieldContext{
 4786		Object:   "CommentEdge",
 4787		Field:    field,
 4788		Args:     nil,
 4789		IsMethod: false,
 4790	}
 4791
 4792	ctx = graphql.WithFieldContext(ctx, fc)
 4793	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4794		ctx = rctx // use context from middleware stack in children
 4795		return obj.Node, nil
 4796	})
 4797	if err != nil {
 4798		ec.Error(ctx, err)
 4799		return graphql.Null
 4800	}
 4801	if resTmp == nil {
 4802		if !graphql.HasFieldError(ctx, fc) {
 4803			ec.Errorf(ctx, "must not be null")
 4804		}
 4805		return graphql.Null
 4806	}
 4807	res := resTmp.(*bug.Comment)
 4808	fc.Result = res
 4809	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4810}
 4811
 4812func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4813	defer func() {
 4814		if r := recover(); r != nil {
 4815			ec.Error(ctx, ec.Recover(ctx, r))
 4816			ret = graphql.Null
 4817		}
 4818	}()
 4819	fc := &graphql.FieldContext{
 4820		Object:   "CommentHistoryStep",
 4821		Field:    field,
 4822		Args:     nil,
 4823		IsMethod: false,
 4824	}
 4825
 4826	ctx = graphql.WithFieldContext(ctx, fc)
 4827	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4828		ctx = rctx // use context from middleware stack in children
 4829		return obj.Message, nil
 4830	})
 4831	if err != nil {
 4832		ec.Error(ctx, err)
 4833		return graphql.Null
 4834	}
 4835	if resTmp == nil {
 4836		if !graphql.HasFieldError(ctx, fc) {
 4837			ec.Errorf(ctx, "must not be null")
 4838		}
 4839		return graphql.Null
 4840	}
 4841	res := resTmp.(string)
 4842	fc.Result = res
 4843	return ec.marshalNString2string(ctx, field.Selections, res)
 4844}
 4845
 4846func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4847	defer func() {
 4848		if r := recover(); r != nil {
 4849			ec.Error(ctx, ec.Recover(ctx, r))
 4850			ret = graphql.Null
 4851		}
 4852	}()
 4853	fc := &graphql.FieldContext{
 4854		Object:   "CommentHistoryStep",
 4855		Field:    field,
 4856		Args:     nil,
 4857		IsMethod: true,
 4858	}
 4859
 4860	ctx = graphql.WithFieldContext(ctx, fc)
 4861	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4862		ctx = rctx // use context from middleware stack in children
 4863		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4864	})
 4865	if err != nil {
 4866		ec.Error(ctx, err)
 4867		return graphql.Null
 4868	}
 4869	if resTmp == nil {
 4870		if !graphql.HasFieldError(ctx, fc) {
 4871			ec.Errorf(ctx, "must not be null")
 4872		}
 4873		return graphql.Null
 4874	}
 4875	res := resTmp.(*time.Time)
 4876	fc.Result = res
 4877	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4878}
 4879
 4880func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4881	defer func() {
 4882		if r := recover(); r != nil {
 4883			ec.Error(ctx, ec.Recover(ctx, r))
 4884			ret = graphql.Null
 4885		}
 4886	}()
 4887	fc := &graphql.FieldContext{
 4888		Object:   "CreateOperation",
 4889		Field:    field,
 4890		Args:     nil,
 4891		IsMethod: true,
 4892	}
 4893
 4894	ctx = graphql.WithFieldContext(ctx, fc)
 4895	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4896		ctx = rctx // use context from middleware stack in children
 4897		return ec.resolvers.CreateOperation().ID(rctx, obj)
 4898	})
 4899	if err != nil {
 4900		ec.Error(ctx, err)
 4901		return graphql.Null
 4902	}
 4903	if resTmp == nil {
 4904		if !graphql.HasFieldError(ctx, fc) {
 4905			ec.Errorf(ctx, "must not be null")
 4906		}
 4907		return graphql.Null
 4908	}
 4909	res := resTmp.(string)
 4910	fc.Result = res
 4911	return ec.marshalNString2string(ctx, field.Selections, res)
 4912}
 4913
 4914func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4915	defer func() {
 4916		if r := recover(); r != nil {
 4917			ec.Error(ctx, ec.Recover(ctx, r))
 4918			ret = graphql.Null
 4919		}
 4920	}()
 4921	fc := &graphql.FieldContext{
 4922		Object:   "CreateOperation",
 4923		Field:    field,
 4924		Args:     nil,
 4925		IsMethod: true,
 4926	}
 4927
 4928	ctx = graphql.WithFieldContext(ctx, fc)
 4929	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4930		ctx = rctx // use context from middleware stack in children
 4931		return ec.resolvers.CreateOperation().Author(rctx, obj)
 4932	})
 4933	if err != nil {
 4934		ec.Error(ctx, err)
 4935		return graphql.Null
 4936	}
 4937	if resTmp == nil {
 4938		if !graphql.HasFieldError(ctx, fc) {
 4939			ec.Errorf(ctx, "must not be null")
 4940		}
 4941		return graphql.Null
 4942	}
 4943	res := resTmp.(models.IdentityWrapper)
 4944	fc.Result = res
 4945	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4946}
 4947
 4948func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4949	defer func() {
 4950		if r := recover(); r != nil {
 4951			ec.Error(ctx, ec.Recover(ctx, r))
 4952			ret = graphql.Null
 4953		}
 4954	}()
 4955	fc := &graphql.FieldContext{
 4956		Object:   "CreateOperation",
 4957		Field:    field,
 4958		Args:     nil,
 4959		IsMethod: true,
 4960	}
 4961
 4962	ctx = graphql.WithFieldContext(ctx, fc)
 4963	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4964		ctx = rctx // use context from middleware stack in children
 4965		return ec.resolvers.CreateOperation().Date(rctx, obj)
 4966	})
 4967	if err != nil {
 4968		ec.Error(ctx, err)
 4969		return graphql.Null
 4970	}
 4971	if resTmp == nil {
 4972		if !graphql.HasFieldError(ctx, fc) {
 4973			ec.Errorf(ctx, "must not be null")
 4974		}
 4975		return graphql.Null
 4976	}
 4977	res := resTmp.(*time.Time)
 4978	fc.Result = res
 4979	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4980}
 4981
 4982func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4983	defer func() {
 4984		if r := recover(); r != nil {
 4985			ec.Error(ctx, ec.Recover(ctx, r))
 4986			ret = graphql.Null
 4987		}
 4988	}()
 4989	fc := &graphql.FieldContext{
 4990		Object:   "CreateOperation",
 4991		Field:    field,
 4992		Args:     nil,
 4993		IsMethod: false,
 4994	}
 4995
 4996	ctx = graphql.WithFieldContext(ctx, fc)
 4997	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4998		ctx = rctx // use context from middleware stack in children
 4999		return obj.Title, nil
 5000	})
 5001	if err != nil {
 5002		ec.Error(ctx, err)
 5003		return graphql.Null
 5004	}
 5005	if resTmp == nil {
 5006		if !graphql.HasFieldError(ctx, fc) {
 5007			ec.Errorf(ctx, "must not be null")
 5008		}
 5009		return graphql.Null
 5010	}
 5011	res := resTmp.(string)
 5012	fc.Result = res
 5013	return ec.marshalNString2string(ctx, field.Selections, res)
 5014}
 5015
 5016func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5017	defer func() {
 5018		if r := recover(); r != nil {
 5019			ec.Error(ctx, ec.Recover(ctx, r))
 5020			ret = graphql.Null
 5021		}
 5022	}()
 5023	fc := &graphql.FieldContext{
 5024		Object:   "CreateOperation",
 5025		Field:    field,
 5026		Args:     nil,
 5027		IsMethod: false,
 5028	}
 5029
 5030	ctx = graphql.WithFieldContext(ctx, fc)
 5031	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5032		ctx = rctx // use context from middleware stack in children
 5033		return obj.Message, nil
 5034	})
 5035	if err != nil {
 5036		ec.Error(ctx, err)
 5037		return graphql.Null
 5038	}
 5039	if resTmp == nil {
 5040		if !graphql.HasFieldError(ctx, fc) {
 5041			ec.Errorf(ctx, "must not be null")
 5042		}
 5043		return graphql.Null
 5044	}
 5045	res := resTmp.(string)
 5046	fc.Result = res
 5047	return ec.marshalNString2string(ctx, field.Selections, res)
 5048}
 5049
 5050func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5051	defer func() {
 5052		if r := recover(); r != nil {
 5053			ec.Error(ctx, ec.Recover(ctx, r))
 5054			ret = graphql.Null
 5055		}
 5056	}()
 5057	fc := &graphql.FieldContext{
 5058		Object:   "CreateOperation",
 5059		Field:    field,
 5060		Args:     nil,
 5061		IsMethod: false,
 5062	}
 5063
 5064	ctx = graphql.WithFieldContext(ctx, fc)
 5065	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5066		ctx = rctx // use context from middleware stack in children
 5067		return obj.Files, nil
 5068	})
 5069	if err != nil {
 5070		ec.Error(ctx, err)
 5071		return graphql.Null
 5072	}
 5073	if resTmp == nil {
 5074		if !graphql.HasFieldError(ctx, fc) {
 5075			ec.Errorf(ctx, "must not be null")
 5076		}
 5077		return graphql.Null
 5078	}
 5079	res := resTmp.([]git.Hash)
 5080	fc.Result = res
 5081	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5082}
 5083
 5084func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5085	defer func() {
 5086		if r := recover(); r != nil {
 5087			ec.Error(ctx, ec.Recover(ctx, r))
 5088			ret = graphql.Null
 5089		}
 5090	}()
 5091	fc := &graphql.FieldContext{
 5092		Object:   "CreateTimelineItem",
 5093		Field:    field,
 5094		Args:     nil,
 5095		IsMethod: true,
 5096	}
 5097
 5098	ctx = graphql.WithFieldContext(ctx, fc)
 5099	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5100		ctx = rctx // use context from middleware stack in children
 5101		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5102	})
 5103	if err != nil {
 5104		ec.Error(ctx, err)
 5105		return graphql.Null
 5106	}
 5107	if resTmp == nil {
 5108		if !graphql.HasFieldError(ctx, fc) {
 5109			ec.Errorf(ctx, "must not be null")
 5110		}
 5111		return graphql.Null
 5112	}
 5113	res := resTmp.(string)
 5114	fc.Result = res
 5115	return ec.marshalNString2string(ctx, field.Selections, res)
 5116}
 5117
 5118func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5119	defer func() {
 5120		if r := recover(); r != nil {
 5121			ec.Error(ctx, ec.Recover(ctx, r))
 5122			ret = graphql.Null
 5123		}
 5124	}()
 5125	fc := &graphql.FieldContext{
 5126		Object:   "CreateTimelineItem",
 5127		Field:    field,
 5128		Args:     nil,
 5129		IsMethod: true,
 5130	}
 5131
 5132	ctx = graphql.WithFieldContext(ctx, fc)
 5133	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5134		ctx = rctx // use context from middleware stack in children
 5135		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
 5136	})
 5137	if err != nil {
 5138		ec.Error(ctx, err)
 5139		return graphql.Null
 5140	}
 5141	if resTmp == nil {
 5142		if !graphql.HasFieldError(ctx, fc) {
 5143			ec.Errorf(ctx, "must not be null")
 5144		}
 5145		return graphql.Null
 5146	}
 5147	res := resTmp.(models.IdentityWrapper)
 5148	fc.Result = res
 5149	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5150}
 5151
 5152func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5153	defer func() {
 5154		if r := recover(); r != nil {
 5155			ec.Error(ctx, ec.Recover(ctx, r))
 5156			ret = graphql.Null
 5157		}
 5158	}()
 5159	fc := &graphql.FieldContext{
 5160		Object:   "CreateTimelineItem",
 5161		Field:    field,
 5162		Args:     nil,
 5163		IsMethod: false,
 5164	}
 5165
 5166	ctx = graphql.WithFieldContext(ctx, fc)
 5167	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5168		ctx = rctx // use context from middleware stack in children
 5169		return obj.Message, nil
 5170	})
 5171	if err != nil {
 5172		ec.Error(ctx, err)
 5173		return graphql.Null
 5174	}
 5175	if resTmp == nil {
 5176		if !graphql.HasFieldError(ctx, fc) {
 5177			ec.Errorf(ctx, "must not be null")
 5178		}
 5179		return graphql.Null
 5180	}
 5181	res := resTmp.(string)
 5182	fc.Result = res
 5183	return ec.marshalNString2string(ctx, field.Selections, res)
 5184}
 5185
 5186func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5187	defer func() {
 5188		if r := recover(); r != nil {
 5189			ec.Error(ctx, ec.Recover(ctx, r))
 5190			ret = graphql.Null
 5191		}
 5192	}()
 5193	fc := &graphql.FieldContext{
 5194		Object:   "CreateTimelineItem",
 5195		Field:    field,
 5196		Args:     nil,
 5197		IsMethod: true,
 5198	}
 5199
 5200	ctx = graphql.WithFieldContext(ctx, fc)
 5201	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5202		ctx = rctx // use context from middleware stack in children
 5203		return obj.MessageIsEmpty(), nil
 5204	})
 5205	if err != nil {
 5206		ec.Error(ctx, err)
 5207		return graphql.Null
 5208	}
 5209	if resTmp == nil {
 5210		if !graphql.HasFieldError(ctx, fc) {
 5211			ec.Errorf(ctx, "must not be null")
 5212		}
 5213		return graphql.Null
 5214	}
 5215	res := resTmp.(bool)
 5216	fc.Result = res
 5217	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5218}
 5219
 5220func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5221	defer func() {
 5222		if r := recover(); r != nil {
 5223			ec.Error(ctx, ec.Recover(ctx, r))
 5224			ret = graphql.Null
 5225		}
 5226	}()
 5227	fc := &graphql.FieldContext{
 5228		Object:   "CreateTimelineItem",
 5229		Field:    field,
 5230		Args:     nil,
 5231		IsMethod: false,
 5232	}
 5233
 5234	ctx = graphql.WithFieldContext(ctx, fc)
 5235	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5236		ctx = rctx // use context from middleware stack in children
 5237		return obj.Files, nil
 5238	})
 5239	if err != nil {
 5240		ec.Error(ctx, err)
 5241		return graphql.Null
 5242	}
 5243	if resTmp == nil {
 5244		if !graphql.HasFieldError(ctx, fc) {
 5245			ec.Errorf(ctx, "must not be null")
 5246		}
 5247		return graphql.Null
 5248	}
 5249	res := resTmp.([]git.Hash)
 5250	fc.Result = res
 5251	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5252}
 5253
 5254func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5255	defer func() {
 5256		if r := recover(); r != nil {
 5257			ec.Error(ctx, ec.Recover(ctx, r))
 5258			ret = graphql.Null
 5259		}
 5260	}()
 5261	fc := &graphql.FieldContext{
 5262		Object:   "CreateTimelineItem",
 5263		Field:    field,
 5264		Args:     nil,
 5265		IsMethod: true,
 5266	}
 5267
 5268	ctx = graphql.WithFieldContext(ctx, fc)
 5269	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5270		ctx = rctx // use context from middleware stack in children
 5271		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5272	})
 5273	if err != nil {
 5274		ec.Error(ctx, err)
 5275		return graphql.Null
 5276	}
 5277	if resTmp == nil {
 5278		if !graphql.HasFieldError(ctx, fc) {
 5279			ec.Errorf(ctx, "must not be null")
 5280		}
 5281		return graphql.Null
 5282	}
 5283	res := resTmp.(*time.Time)
 5284	fc.Result = res
 5285	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5286}
 5287
 5288func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5289	defer func() {
 5290		if r := recover(); r != nil {
 5291			ec.Error(ctx, ec.Recover(ctx, r))
 5292			ret = graphql.Null
 5293		}
 5294	}()
 5295	fc := &graphql.FieldContext{
 5296		Object:   "CreateTimelineItem",
 5297		Field:    field,
 5298		Args:     nil,
 5299		IsMethod: true,
 5300	}
 5301
 5302	ctx = graphql.WithFieldContext(ctx, fc)
 5303	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5304		ctx = rctx // use context from middleware stack in children
 5305		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5306	})
 5307	if err != nil {
 5308		ec.Error(ctx, err)
 5309		return graphql.Null
 5310	}
 5311	if resTmp == nil {
 5312		if !graphql.HasFieldError(ctx, fc) {
 5313			ec.Errorf(ctx, "must not be null")
 5314		}
 5315		return graphql.Null
 5316	}
 5317	res := resTmp.(*time.Time)
 5318	fc.Result = res
 5319	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5320}
 5321
 5322func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5323	defer func() {
 5324		if r := recover(); r != nil {
 5325			ec.Error(ctx, ec.Recover(ctx, r))
 5326			ret = graphql.Null
 5327		}
 5328	}()
 5329	fc := &graphql.FieldContext{
 5330		Object:   "CreateTimelineItem",
 5331		Field:    field,
 5332		Args:     nil,
 5333		IsMethod: true,
 5334	}
 5335
 5336	ctx = graphql.WithFieldContext(ctx, fc)
 5337	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5338		ctx = rctx // use context from middleware stack in children
 5339		return obj.Edited(), nil
 5340	})
 5341	if err != nil {
 5342		ec.Error(ctx, err)
 5343		return graphql.Null
 5344	}
 5345	if resTmp == nil {
 5346		if !graphql.HasFieldError(ctx, fc) {
 5347			ec.Errorf(ctx, "must not be null")
 5348		}
 5349		return graphql.Null
 5350	}
 5351	res := resTmp.(bool)
 5352	fc.Result = res
 5353	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5354}
 5355
 5356func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5357	defer func() {
 5358		if r := recover(); r != nil {
 5359			ec.Error(ctx, ec.Recover(ctx, r))
 5360			ret = graphql.Null
 5361		}
 5362	}()
 5363	fc := &graphql.FieldContext{
 5364		Object:   "CreateTimelineItem",
 5365		Field:    field,
 5366		Args:     nil,
 5367		IsMethod: false,
 5368	}
 5369
 5370	ctx = graphql.WithFieldContext(ctx, fc)
 5371	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5372		ctx = rctx // use context from middleware stack in children
 5373		return obj.History, nil
 5374	})
 5375	if err != nil {
 5376		ec.Error(ctx, err)
 5377		return graphql.Null
 5378	}
 5379	if resTmp == nil {
 5380		if !graphql.HasFieldError(ctx, fc) {
 5381			ec.Errorf(ctx, "must not be null")
 5382		}
 5383		return graphql.Null
 5384	}
 5385	res := resTmp.([]bug.CommentHistoryStep)
 5386	fc.Result = res
 5387	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5388}
 5389
 5390func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5391	defer func() {
 5392		if r := recover(); r != nil {
 5393			ec.Error(ctx, ec.Recover(ctx, r))
 5394			ret = graphql.Null
 5395		}
 5396	}()
 5397	fc := &graphql.FieldContext{
 5398		Object:   "EditCommentOperation",
 5399		Field:    field,
 5400		Args:     nil,
 5401		IsMethod: true,
 5402	}
 5403
 5404	ctx = graphql.WithFieldContext(ctx, fc)
 5405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5406		ctx = rctx // use context from middleware stack in children
 5407		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5408	})
 5409	if err != nil {
 5410		ec.Error(ctx, err)
 5411		return graphql.Null
 5412	}
 5413	if resTmp == nil {
 5414		if !graphql.HasFieldError(ctx, fc) {
 5415			ec.Errorf(ctx, "must not be null")
 5416		}
 5417		return graphql.Null
 5418	}
 5419	res := resTmp.(string)
 5420	fc.Result = res
 5421	return ec.marshalNString2string(ctx, field.Selections, res)
 5422}
 5423
 5424func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5425	defer func() {
 5426		if r := recover(); r != nil {
 5427			ec.Error(ctx, ec.Recover(ctx, r))
 5428			ret = graphql.Null
 5429		}
 5430	}()
 5431	fc := &graphql.FieldContext{
 5432		Object:   "EditCommentOperation",
 5433		Field:    field,
 5434		Args:     nil,
 5435		IsMethod: true,
 5436	}
 5437
 5438	ctx = graphql.WithFieldContext(ctx, fc)
 5439	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5440		ctx = rctx // use context from middleware stack in children
 5441		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
 5442	})
 5443	if err != nil {
 5444		ec.Error(ctx, err)
 5445		return graphql.Null
 5446	}
 5447	if resTmp == nil {
 5448		if !graphql.HasFieldError(ctx, fc) {
 5449			ec.Errorf(ctx, "must not be null")
 5450		}
 5451		return graphql.Null
 5452	}
 5453	res := resTmp.(models.IdentityWrapper)
 5454	fc.Result = res
 5455	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5456}
 5457
 5458func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5459	defer func() {
 5460		if r := recover(); r != nil {
 5461			ec.Error(ctx, ec.Recover(ctx, r))
 5462			ret = graphql.Null
 5463		}
 5464	}()
 5465	fc := &graphql.FieldContext{
 5466		Object:   "EditCommentOperation",
 5467		Field:    field,
 5468		Args:     nil,
 5469		IsMethod: true,
 5470	}
 5471
 5472	ctx = graphql.WithFieldContext(ctx, fc)
 5473	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5474		ctx = rctx // use context from middleware stack in children
 5475		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5476	})
 5477	if err != nil {
 5478		ec.Error(ctx, err)
 5479		return graphql.Null
 5480	}
 5481	if resTmp == nil {
 5482		if !graphql.HasFieldError(ctx, fc) {
 5483			ec.Errorf(ctx, "must not be null")
 5484		}
 5485		return graphql.Null
 5486	}
 5487	res := resTmp.(*time.Time)
 5488	fc.Result = res
 5489	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5490}
 5491
 5492func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5493	defer func() {
 5494		if r := recover(); r != nil {
 5495			ec.Error(ctx, ec.Recover(ctx, r))
 5496			ret = graphql.Null
 5497		}
 5498	}()
 5499	fc := &graphql.FieldContext{
 5500		Object:   "EditCommentOperation",
 5501		Field:    field,
 5502		Args:     nil,
 5503		IsMethod: true,
 5504	}
 5505
 5506	ctx = graphql.WithFieldContext(ctx, fc)
 5507	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5508		ctx = rctx // use context from middleware stack in children
 5509		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5510	})
 5511	if err != nil {
 5512		ec.Error(ctx, err)
 5513		return graphql.Null
 5514	}
 5515	if resTmp == nil {
 5516		if !graphql.HasFieldError(ctx, fc) {
 5517			ec.Errorf(ctx, "must not be null")
 5518		}
 5519		return graphql.Null
 5520	}
 5521	res := resTmp.(string)
 5522	fc.Result = res
 5523	return ec.marshalNString2string(ctx, field.Selections, res)
 5524}
 5525
 5526func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5527	defer func() {
 5528		if r := recover(); r != nil {
 5529			ec.Error(ctx, ec.Recover(ctx, r))
 5530			ret = graphql.Null
 5531		}
 5532	}()
 5533	fc := &graphql.FieldContext{
 5534		Object:   "EditCommentOperation",
 5535		Field:    field,
 5536		Args:     nil,
 5537		IsMethod: false,
 5538	}
 5539
 5540	ctx = graphql.WithFieldContext(ctx, fc)
 5541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5542		ctx = rctx // use context from middleware stack in children
 5543		return obj.Message, nil
 5544	})
 5545	if err != nil {
 5546		ec.Error(ctx, err)
 5547		return graphql.Null
 5548	}
 5549	if resTmp == nil {
 5550		if !graphql.HasFieldError(ctx, fc) {
 5551			ec.Errorf(ctx, "must not be null")
 5552		}
 5553		return graphql.Null
 5554	}
 5555	res := resTmp.(string)
 5556	fc.Result = res
 5557	return ec.marshalNString2string(ctx, field.Selections, res)
 5558}
 5559
 5560func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5561	defer func() {
 5562		if r := recover(); r != nil {
 5563			ec.Error(ctx, ec.Recover(ctx, r))
 5564			ret = graphql.Null
 5565		}
 5566	}()
 5567	fc := &graphql.FieldContext{
 5568		Object:   "EditCommentOperation",
 5569		Field:    field,
 5570		Args:     nil,
 5571		IsMethod: false,
 5572	}
 5573
 5574	ctx = graphql.WithFieldContext(ctx, fc)
 5575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5576		ctx = rctx // use context from middleware stack in children
 5577		return obj.Files, nil
 5578	})
 5579	if err != nil {
 5580		ec.Error(ctx, err)
 5581		return graphql.Null
 5582	}
 5583	if resTmp == nil {
 5584		if !graphql.HasFieldError(ctx, fc) {
 5585			ec.Errorf(ctx, "must not be null")
 5586		}
 5587		return graphql.Null
 5588	}
 5589	res := resTmp.([]git.Hash)
 5590	fc.Result = res
 5591	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5592}
 5593
 5594func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5595	defer func() {
 5596		if r := recover(); r != nil {
 5597			ec.Error(ctx, ec.Recover(ctx, r))
 5598			ret = graphql.Null
 5599		}
 5600	}()
 5601	fc := &graphql.FieldContext{
 5602		Object:   "Identity",
 5603		Field:    field,
 5604		Args:     nil,
 5605		IsMethod: true,
 5606	}
 5607
 5608	ctx = graphql.WithFieldContext(ctx, fc)
 5609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5610		ctx = rctx // use context from middleware stack in children
 5611		return ec.resolvers.Identity().ID(rctx, obj)
 5612	})
 5613	if err != nil {
 5614		ec.Error(ctx, err)
 5615		return graphql.Null
 5616	}
 5617	if resTmp == nil {
 5618		if !graphql.HasFieldError(ctx, fc) {
 5619			ec.Errorf(ctx, "must not be null")
 5620		}
 5621		return graphql.Null
 5622	}
 5623	res := resTmp.(string)
 5624	fc.Result = res
 5625	return ec.marshalNString2string(ctx, field.Selections, res)
 5626}
 5627
 5628func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5629	defer func() {
 5630		if r := recover(); r != nil {
 5631			ec.Error(ctx, ec.Recover(ctx, r))
 5632			ret = graphql.Null
 5633		}
 5634	}()
 5635	fc := &graphql.FieldContext{
 5636		Object:   "Identity",
 5637		Field:    field,
 5638		Args:     nil,
 5639		IsMethod: true,
 5640	}
 5641
 5642	ctx = graphql.WithFieldContext(ctx, fc)
 5643	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5644		ctx = rctx // use context from middleware stack in children
 5645		return ec.resolvers.Identity().HumanID(rctx, obj)
 5646	})
 5647	if err != nil {
 5648		ec.Error(ctx, err)
 5649		return graphql.Null
 5650	}
 5651	if resTmp == nil {
 5652		if !graphql.HasFieldError(ctx, fc) {
 5653			ec.Errorf(ctx, "must not be null")
 5654		}
 5655		return graphql.Null
 5656	}
 5657	res := resTmp.(string)
 5658	fc.Result = res
 5659	return ec.marshalNString2string(ctx, field.Selections, res)
 5660}
 5661
 5662func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5663	defer func() {
 5664		if r := recover(); r != nil {
 5665			ec.Error(ctx, ec.Recover(ctx, r))
 5666			ret = graphql.Null
 5667		}
 5668	}()
 5669	fc := &graphql.FieldContext{
 5670		Object:   "Identity",
 5671		Field:    field,
 5672		Args:     nil,
 5673		IsMethod: true,
 5674	}
 5675
 5676	ctx = graphql.WithFieldContext(ctx, fc)
 5677	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5678		ctx = rctx // use context from middleware stack in children
 5679		return obj.Name(), nil
 5680	})
 5681	if err != nil {
 5682		ec.Error(ctx, err)
 5683		return graphql.Null
 5684	}
 5685	if resTmp == nil {
 5686		return graphql.Null
 5687	}
 5688	res := resTmp.(string)
 5689	fc.Result = res
 5690	return ec.marshalOString2string(ctx, field.Selections, res)
 5691}
 5692
 5693func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5694	defer func() {
 5695		if r := recover(); r != nil {
 5696			ec.Error(ctx, ec.Recover(ctx, r))
 5697			ret = graphql.Null
 5698		}
 5699	}()
 5700	fc := &graphql.FieldContext{
 5701		Object:   "Identity",
 5702		Field:    field,
 5703		Args:     nil,
 5704		IsMethod: true,
 5705	}
 5706
 5707	ctx = graphql.WithFieldContext(ctx, fc)
 5708	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5709		ctx = rctx // use context from middleware stack in children
 5710		return obj.Email()
 5711	})
 5712	if err != nil {
 5713		ec.Error(ctx, err)
 5714		return graphql.Null
 5715	}
 5716	if resTmp == nil {
 5717		return graphql.Null
 5718	}
 5719	res := resTmp.(string)
 5720	fc.Result = res
 5721	return ec.marshalOString2string(ctx, field.Selections, res)
 5722}
 5723
 5724func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5725	defer func() {
 5726		if r := recover(); r != nil {
 5727			ec.Error(ctx, ec.Recover(ctx, r))
 5728			ret = graphql.Null
 5729		}
 5730	}()
 5731	fc := &graphql.FieldContext{
 5732		Object:   "Identity",
 5733		Field:    field,
 5734		Args:     nil,
 5735		IsMethod: true,
 5736	}
 5737
 5738	ctx = graphql.WithFieldContext(ctx, fc)
 5739	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5740		ctx = rctx // use context from middleware stack in children
 5741		return obj.Login()
 5742	})
 5743	if err != nil {
 5744		ec.Error(ctx, err)
 5745		return graphql.Null
 5746	}
 5747	if resTmp == nil {
 5748		return graphql.Null
 5749	}
 5750	res := resTmp.(string)
 5751	fc.Result = res
 5752	return ec.marshalOString2string(ctx, field.Selections, res)
 5753}
 5754
 5755func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5756	defer func() {
 5757		if r := recover(); r != nil {
 5758			ec.Error(ctx, ec.Recover(ctx, r))
 5759			ret = graphql.Null
 5760		}
 5761	}()
 5762	fc := &graphql.FieldContext{
 5763		Object:   "Identity",
 5764		Field:    field,
 5765		Args:     nil,
 5766		IsMethod: true,
 5767	}
 5768
 5769	ctx = graphql.WithFieldContext(ctx, fc)
 5770	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5771		ctx = rctx // use context from middleware stack in children
 5772		return obj.DisplayName(), nil
 5773	})
 5774	if err != nil {
 5775		ec.Error(ctx, err)
 5776		return graphql.Null
 5777	}
 5778	if resTmp == nil {
 5779		if !graphql.HasFieldError(ctx, fc) {
 5780			ec.Errorf(ctx, "must not be null")
 5781		}
 5782		return graphql.Null
 5783	}
 5784	res := resTmp.(string)
 5785	fc.Result = res
 5786	return ec.marshalNString2string(ctx, field.Selections, res)
 5787}
 5788
 5789func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5790	defer func() {
 5791		if r := recover(); r != nil {
 5792			ec.Error(ctx, ec.Recover(ctx, r))
 5793			ret = graphql.Null
 5794		}
 5795	}()
 5796	fc := &graphql.FieldContext{
 5797		Object:   "Identity",
 5798		Field:    field,
 5799		Args:     nil,
 5800		IsMethod: true,
 5801	}
 5802
 5803	ctx = graphql.WithFieldContext(ctx, fc)
 5804	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5805		ctx = rctx // use context from middleware stack in children
 5806		return obj.AvatarUrl()
 5807	})
 5808	if err != nil {
 5809		ec.Error(ctx, err)
 5810		return graphql.Null
 5811	}
 5812	if resTmp == nil {
 5813		return graphql.Null
 5814	}
 5815	res := resTmp.(string)
 5816	fc.Result = res
 5817	return ec.marshalOString2string(ctx, field.Selections, res)
 5818}
 5819
 5820func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5821	defer func() {
 5822		if r := recover(); r != nil {
 5823			ec.Error(ctx, ec.Recover(ctx, r))
 5824			ret = graphql.Null
 5825		}
 5826	}()
 5827	fc := &graphql.FieldContext{
 5828		Object:   "Identity",
 5829		Field:    field,
 5830		Args:     nil,
 5831		IsMethod: true,
 5832	}
 5833
 5834	ctx = graphql.WithFieldContext(ctx, fc)
 5835	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5836		ctx = rctx // use context from middleware stack in children
 5837		return obj.IsProtected()
 5838	})
 5839	if err != nil {
 5840		ec.Error(ctx, err)
 5841		return graphql.Null
 5842	}
 5843	if resTmp == nil {
 5844		if !graphql.HasFieldError(ctx, fc) {
 5845			ec.Errorf(ctx, "must not be null")
 5846		}
 5847		return graphql.Null
 5848	}
 5849	res := resTmp.(bool)
 5850	fc.Result = res
 5851	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5852}
 5853
 5854func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5855	defer func() {
 5856		if r := recover(); r != nil {
 5857			ec.Error(ctx, ec.Recover(ctx, r))
 5858			ret = graphql.Null
 5859		}
 5860	}()
 5861	fc := &graphql.FieldContext{
 5862		Object:   "IdentityConnection",
 5863		Field:    field,
 5864		Args:     nil,
 5865		IsMethod: false,
 5866	}
 5867
 5868	ctx = graphql.WithFieldContext(ctx, fc)
 5869	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5870		ctx = rctx // use context from middleware stack in children
 5871		return obj.Edges, nil
 5872	})
 5873	if err != nil {
 5874		ec.Error(ctx, err)
 5875		return graphql.Null
 5876	}
 5877	if resTmp == nil {
 5878		if !graphql.HasFieldError(ctx, fc) {
 5879			ec.Errorf(ctx, "must not be null")
 5880		}
 5881		return graphql.Null
 5882	}
 5883	res := resTmp.([]*models.IdentityEdge)
 5884	fc.Result = res
 5885	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 5886}
 5887
 5888func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5889	defer func() {
 5890		if r := recover(); r != nil {
 5891			ec.Error(ctx, ec.Recover(ctx, r))
 5892			ret = graphql.Null
 5893		}
 5894	}()
 5895	fc := &graphql.FieldContext{
 5896		Object:   "IdentityConnection",
 5897		Field:    field,
 5898		Args:     nil,
 5899		IsMethod: false,
 5900	}
 5901
 5902	ctx = graphql.WithFieldContext(ctx, fc)
 5903	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5904		ctx = rctx // use context from middleware stack in children
 5905		return obj.Nodes, nil
 5906	})
 5907	if err != nil {
 5908		ec.Error(ctx, err)
 5909		return graphql.Null
 5910	}
 5911	if resTmp == nil {
 5912		if !graphql.HasFieldError(ctx, fc) {
 5913			ec.Errorf(ctx, "must not be null")
 5914		}
 5915		return graphql.Null
 5916	}
 5917	res := resTmp.([]models.IdentityWrapper)
 5918	fc.Result = res
 5919	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
 5920}
 5921
 5922func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5923	defer func() {
 5924		if r := recover(); r != nil {
 5925			ec.Error(ctx, ec.Recover(ctx, r))
 5926			ret = graphql.Null
 5927		}
 5928	}()
 5929	fc := &graphql.FieldContext{
 5930		Object:   "IdentityConnection",
 5931		Field:    field,
 5932		Args:     nil,
 5933		IsMethod: false,
 5934	}
 5935
 5936	ctx = graphql.WithFieldContext(ctx, fc)
 5937	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5938		ctx = rctx // use context from middleware stack in children
 5939		return obj.PageInfo, nil
 5940	})
 5941	if err != nil {
 5942		ec.Error(ctx, err)
 5943		return graphql.Null
 5944	}
 5945	if resTmp == nil {
 5946		if !graphql.HasFieldError(ctx, fc) {
 5947			ec.Errorf(ctx, "must not be null")
 5948		}
 5949		return graphql.Null
 5950	}
 5951	res := resTmp.(*models.PageInfo)
 5952	fc.Result = res
 5953	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 5954}
 5955
 5956func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5957	defer func() {
 5958		if r := recover(); r != nil {
 5959			ec.Error(ctx, ec.Recover(ctx, r))
 5960			ret = graphql.Null
 5961		}
 5962	}()
 5963	fc := &graphql.FieldContext{
 5964		Object:   "IdentityConnection",
 5965		Field:    field,
 5966		Args:     nil,
 5967		IsMethod: false,
 5968	}
 5969
 5970	ctx = graphql.WithFieldContext(ctx, fc)
 5971	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5972		ctx = rctx // use context from middleware stack in children
 5973		return obj.TotalCount, nil
 5974	})
 5975	if err != nil {
 5976		ec.Error(ctx, err)
 5977		return graphql.Null
 5978	}
 5979	if resTmp == nil {
 5980		if !graphql.HasFieldError(ctx, fc) {
 5981			ec.Errorf(ctx, "must not be null")
 5982		}
 5983		return graphql.Null
 5984	}
 5985	res := resTmp.(int)
 5986	fc.Result = res
 5987	return ec.marshalNInt2int(ctx, field.Selections, res)
 5988}
 5989
 5990func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 5991	defer func() {
 5992		if r := recover(); r != nil {
 5993			ec.Error(ctx, ec.Recover(ctx, r))
 5994			ret = graphql.Null
 5995		}
 5996	}()
 5997	fc := &graphql.FieldContext{
 5998		Object:   "IdentityEdge",
 5999		Field:    field,
 6000		Args:     nil,
 6001		IsMethod: false,
 6002	}
 6003
 6004	ctx = graphql.WithFieldContext(ctx, fc)
 6005	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6006		ctx = rctx // use context from middleware stack in children
 6007		return obj.Cursor, nil
 6008	})
 6009	if err != nil {
 6010		ec.Error(ctx, err)
 6011		return graphql.Null
 6012	}
 6013	if resTmp == nil {
 6014		if !graphql.HasFieldError(ctx, fc) {
 6015			ec.Errorf(ctx, "must not be null")
 6016		}
 6017		return graphql.Null
 6018	}
 6019	res := resTmp.(string)
 6020	fc.Result = res
 6021	return ec.marshalNString2string(ctx, field.Selections, res)
 6022}
 6023
 6024func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6025	defer func() {
 6026		if r := recover(); r != nil {
 6027			ec.Error(ctx, ec.Recover(ctx, r))
 6028			ret = graphql.Null
 6029		}
 6030	}()
 6031	fc := &graphql.FieldContext{
 6032		Object:   "IdentityEdge",
 6033		Field:    field,
 6034		Args:     nil,
 6035		IsMethod: false,
 6036	}
 6037
 6038	ctx = graphql.WithFieldContext(ctx, fc)
 6039	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6040		ctx = rctx // use context from middleware stack in children
 6041		return obj.Node, nil
 6042	})
 6043	if err != nil {
 6044		ec.Error(ctx, err)
 6045		return graphql.Null
 6046	}
 6047	if resTmp == nil {
 6048		if !graphql.HasFieldError(ctx, fc) {
 6049			ec.Errorf(ctx, "must not be null")
 6050		}
 6051		return graphql.Null
 6052	}
 6053	res := resTmp.(models.IdentityWrapper)
 6054	fc.Result = res
 6055	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6056}
 6057
 6058func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6059	defer func() {
 6060		if r := recover(); r != nil {
 6061			ec.Error(ctx, ec.Recover(ctx, r))
 6062			ret = graphql.Null
 6063		}
 6064	}()
 6065	fc := &graphql.FieldContext{
 6066		Object:   "Label",
 6067		Field:    field,
 6068		Args:     nil,
 6069		IsMethod: true,
 6070	}
 6071
 6072	ctx = graphql.WithFieldContext(ctx, fc)
 6073	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6074		ctx = rctx // use context from middleware stack in children
 6075		return ec.resolvers.Label().Name(rctx, obj)
 6076	})
 6077	if err != nil {
 6078		ec.Error(ctx, err)
 6079		return graphql.Null
 6080	}
 6081	if resTmp == nil {
 6082		if !graphql.HasFieldError(ctx, fc) {
 6083			ec.Errorf(ctx, "must not be null")
 6084		}
 6085		return graphql.Null
 6086	}
 6087	res := resTmp.(string)
 6088	fc.Result = res
 6089	return ec.marshalNString2string(ctx, field.Selections, res)
 6090}
 6091
 6092func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6093	defer func() {
 6094		if r := recover(); r != nil {
 6095			ec.Error(ctx, ec.Recover(ctx, r))
 6096			ret = graphql.Null
 6097		}
 6098	}()
 6099	fc := &graphql.FieldContext{
 6100		Object:   "Label",
 6101		Field:    field,
 6102		Args:     nil,
 6103		IsMethod: true,
 6104	}
 6105
 6106	ctx = graphql.WithFieldContext(ctx, fc)
 6107	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6108		ctx = rctx // use context from middleware stack in children
 6109		return ec.resolvers.Label().Color(rctx, obj)
 6110	})
 6111	if err != nil {
 6112		ec.Error(ctx, err)
 6113		return graphql.Null
 6114	}
 6115	if resTmp == nil {
 6116		if !graphql.HasFieldError(ctx, fc) {
 6117			ec.Errorf(ctx, "must not be null")
 6118		}
 6119		return graphql.Null
 6120	}
 6121	res := resTmp.(*color.RGBA)
 6122	fc.Result = res
 6123	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6124}
 6125
 6126func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6127	defer func() {
 6128		if r := recover(); r != nil {
 6129			ec.Error(ctx, ec.Recover(ctx, r))
 6130			ret = graphql.Null
 6131		}
 6132	}()
 6133	fc := &graphql.FieldContext{
 6134		Object:   "LabelChangeOperation",
 6135		Field:    field,
 6136		Args:     nil,
 6137		IsMethod: true,
 6138	}
 6139
 6140	ctx = graphql.WithFieldContext(ctx, fc)
 6141	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6142		ctx = rctx // use context from middleware stack in children
 6143		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6144	})
 6145	if err != nil {
 6146		ec.Error(ctx, err)
 6147		return graphql.Null
 6148	}
 6149	if resTmp == nil {
 6150		if !graphql.HasFieldError(ctx, fc) {
 6151			ec.Errorf(ctx, "must not be null")
 6152		}
 6153		return graphql.Null
 6154	}
 6155	res := resTmp.(string)
 6156	fc.Result = res
 6157	return ec.marshalNString2string(ctx, field.Selections, res)
 6158}
 6159
 6160func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6161	defer func() {
 6162		if r := recover(); r != nil {
 6163			ec.Error(ctx, ec.Recover(ctx, r))
 6164			ret = graphql.Null
 6165		}
 6166	}()
 6167	fc := &graphql.FieldContext{
 6168		Object:   "LabelChangeOperation",
 6169		Field:    field,
 6170		Args:     nil,
 6171		IsMethod: true,
 6172	}
 6173
 6174	ctx = graphql.WithFieldContext(ctx, fc)
 6175	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6176		ctx = rctx // use context from middleware stack in children
 6177		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
 6178	})
 6179	if err != nil {
 6180		ec.Error(ctx, err)
 6181		return graphql.Null
 6182	}
 6183	if resTmp == nil {
 6184		if !graphql.HasFieldError(ctx, fc) {
 6185			ec.Errorf(ctx, "must not be null")
 6186		}
 6187		return graphql.Null
 6188	}
 6189	res := resTmp.(models.IdentityWrapper)
 6190	fc.Result = res
 6191	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6192}
 6193
 6194func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6195	defer func() {
 6196		if r := recover(); r != nil {
 6197			ec.Error(ctx, ec.Recover(ctx, r))
 6198			ret = graphql.Null
 6199		}
 6200	}()
 6201	fc := &graphql.FieldContext{
 6202		Object:   "LabelChangeOperation",
 6203		Field:    field,
 6204		Args:     nil,
 6205		IsMethod: true,
 6206	}
 6207
 6208	ctx = graphql.WithFieldContext(ctx, fc)
 6209	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6210		ctx = rctx // use context from middleware stack in children
 6211		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6212	})
 6213	if err != nil {
 6214		ec.Error(ctx, err)
 6215		return graphql.Null
 6216	}
 6217	if resTmp == nil {
 6218		if !graphql.HasFieldError(ctx, fc) {
 6219			ec.Errorf(ctx, "must not be null")
 6220		}
 6221		return graphql.Null
 6222	}
 6223	res := resTmp.(*time.Time)
 6224	fc.Result = res
 6225	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6226}
 6227
 6228func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6229	defer func() {
 6230		if r := recover(); r != nil {
 6231			ec.Error(ctx, ec.Recover(ctx, r))
 6232			ret = graphql.Null
 6233		}
 6234	}()
 6235	fc := &graphql.FieldContext{
 6236		Object:   "LabelChangeOperation",
 6237		Field:    field,
 6238		Args:     nil,
 6239		IsMethod: false,
 6240	}
 6241
 6242	ctx = graphql.WithFieldContext(ctx, fc)
 6243	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6244		ctx = rctx // use context from middleware stack in children
 6245		return obj.Added, nil
 6246	})
 6247	if err != nil {
 6248		ec.Error(ctx, err)
 6249		return graphql.Null
 6250	}
 6251	if resTmp == nil {
 6252		if !graphql.HasFieldError(ctx, fc) {
 6253			ec.Errorf(ctx, "must not be null")
 6254		}
 6255		return graphql.Null
 6256	}
 6257	res := resTmp.([]bug.Label)
 6258	fc.Result = res
 6259	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6260}
 6261
 6262func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6263	defer func() {
 6264		if r := recover(); r != nil {
 6265			ec.Error(ctx, ec.Recover(ctx, r))
 6266			ret = graphql.Null
 6267		}
 6268	}()
 6269	fc := &graphql.FieldContext{
 6270		Object:   "LabelChangeOperation",
 6271		Field:    field,
 6272		Args:     nil,
 6273		IsMethod: false,
 6274	}
 6275
 6276	ctx = graphql.WithFieldContext(ctx, fc)
 6277	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6278		ctx = rctx // use context from middleware stack in children
 6279		return obj.Removed, nil
 6280	})
 6281	if err != nil {
 6282		ec.Error(ctx, err)
 6283		return graphql.Null
 6284	}
 6285	if resTmp == nil {
 6286		if !graphql.HasFieldError(ctx, fc) {
 6287			ec.Errorf(ctx, "must not be null")
 6288		}
 6289		return graphql.Null
 6290	}
 6291	res := resTmp.([]bug.Label)
 6292	fc.Result = res
 6293	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6294}
 6295
 6296func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6297	defer func() {
 6298		if r := recover(); r != nil {
 6299			ec.Error(ctx, ec.Recover(ctx, r))
 6300			ret = graphql.Null
 6301		}
 6302	}()
 6303	fc := &graphql.FieldContext{
 6304		Object:   "LabelChangeResult",
 6305		Field:    field,
 6306		Args:     nil,
 6307		IsMethod: false,
 6308	}
 6309
 6310	ctx = graphql.WithFieldContext(ctx, fc)
 6311	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6312		ctx = rctx // use context from middleware stack in children
 6313		return obj.Label, nil
 6314	})
 6315	if err != nil {
 6316		ec.Error(ctx, err)
 6317		return graphql.Null
 6318	}
 6319	if resTmp == nil {
 6320		if !graphql.HasFieldError(ctx, fc) {
 6321			ec.Errorf(ctx, "must not be null")
 6322		}
 6323		return graphql.Null
 6324	}
 6325	res := resTmp.(bug.Label)
 6326	fc.Result = res
 6327	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6328}
 6329
 6330func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6331	defer func() {
 6332		if r := recover(); r != nil {
 6333			ec.Error(ctx, ec.Recover(ctx, r))
 6334			ret = graphql.Null
 6335		}
 6336	}()
 6337	fc := &graphql.FieldContext{
 6338		Object:   "LabelChangeResult",
 6339		Field:    field,
 6340		Args:     nil,
 6341		IsMethod: true,
 6342	}
 6343
 6344	ctx = graphql.WithFieldContext(ctx, fc)
 6345	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6346		ctx = rctx // use context from middleware stack in children
 6347		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6348	})
 6349	if err != nil {
 6350		ec.Error(ctx, err)
 6351		return graphql.Null
 6352	}
 6353	if resTmp == nil {
 6354		if !graphql.HasFieldError(ctx, fc) {
 6355			ec.Errorf(ctx, "must not be null")
 6356		}
 6357		return graphql.Null
 6358	}
 6359	res := resTmp.(models.LabelChangeStatus)
 6360	fc.Result = res
 6361	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6362}
 6363
 6364func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6365	defer func() {
 6366		if r := recover(); r != nil {
 6367			ec.Error(ctx, ec.Recover(ctx, r))
 6368			ret = graphql.Null
 6369		}
 6370	}()
 6371	fc := &graphql.FieldContext{
 6372		Object:   "LabelChangeTimelineItem",
 6373		Field:    field,
 6374		Args:     nil,
 6375		IsMethod: true,
 6376	}
 6377
 6378	ctx = graphql.WithFieldContext(ctx, fc)
 6379	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6380		ctx = rctx // use context from middleware stack in children
 6381		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6382	})
 6383	if err != nil {
 6384		ec.Error(ctx, err)
 6385		return graphql.Null
 6386	}
 6387	if resTmp == nil {
 6388		if !graphql.HasFieldError(ctx, fc) {
 6389			ec.Errorf(ctx, "must not be null")
 6390		}
 6391		return graphql.Null
 6392	}
 6393	res := resTmp.(string)
 6394	fc.Result = res
 6395	return ec.marshalNString2string(ctx, field.Selections, res)
 6396}
 6397
 6398func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6399	defer func() {
 6400		if r := recover(); r != nil {
 6401			ec.Error(ctx, ec.Recover(ctx, r))
 6402			ret = graphql.Null
 6403		}
 6404	}()
 6405	fc := &graphql.FieldContext{
 6406		Object:   "LabelChangeTimelineItem",
 6407		Field:    field,
 6408		Args:     nil,
 6409		IsMethod: true,
 6410	}
 6411
 6412	ctx = graphql.WithFieldContext(ctx, fc)
 6413	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6414		ctx = rctx // use context from middleware stack in children
 6415		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
 6416	})
 6417	if err != nil {
 6418		ec.Error(ctx, err)
 6419		return graphql.Null
 6420	}
 6421	if resTmp == nil {
 6422		if !graphql.HasFieldError(ctx, fc) {
 6423			ec.Errorf(ctx, "must not be null")
 6424		}
 6425		return graphql.Null
 6426	}
 6427	res := resTmp.(models.IdentityWrapper)
 6428	fc.Result = res
 6429	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6430}
 6431
 6432func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6433	defer func() {
 6434		if r := recover(); r != nil {
 6435			ec.Error(ctx, ec.Recover(ctx, r))
 6436			ret = graphql.Null
 6437		}
 6438	}()
 6439	fc := &graphql.FieldContext{
 6440		Object:   "LabelChangeTimelineItem",
 6441		Field:    field,
 6442		Args:     nil,
 6443		IsMethod: true,
 6444	}
 6445
 6446	ctx = graphql.WithFieldContext(ctx, fc)
 6447	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6448		ctx = rctx // use context from middleware stack in children
 6449		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6450	})
 6451	if err != nil {
 6452		ec.Error(ctx, err)
 6453		return graphql.Null
 6454	}
 6455	if resTmp == nil {
 6456		if !graphql.HasFieldError(ctx, fc) {
 6457			ec.Errorf(ctx, "must not be null")
 6458		}
 6459		return graphql.Null
 6460	}
 6461	res := resTmp.(*time.Time)
 6462	fc.Result = res
 6463	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6464}
 6465
 6466func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6467	defer func() {
 6468		if r := recover(); r != nil {
 6469			ec.Error(ctx, ec.Recover(ctx, r))
 6470			ret = graphql.Null
 6471		}
 6472	}()
 6473	fc := &graphql.FieldContext{
 6474		Object:   "LabelChangeTimelineItem",
 6475		Field:    field,
 6476		Args:     nil,
 6477		IsMethod: false,
 6478	}
 6479
 6480	ctx = graphql.WithFieldContext(ctx, fc)
 6481	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6482		ctx = rctx // use context from middleware stack in children
 6483		return obj.Added, nil
 6484	})
 6485	if err != nil {
 6486		ec.Error(ctx, err)
 6487		return graphql.Null
 6488	}
 6489	if resTmp == nil {
 6490		if !graphql.HasFieldError(ctx, fc) {
 6491			ec.Errorf(ctx, "must not be null")
 6492		}
 6493		return graphql.Null
 6494	}
 6495	res := resTmp.([]bug.Label)
 6496	fc.Result = res
 6497	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6498}
 6499
 6500func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6501	defer func() {
 6502		if r := recover(); r != nil {
 6503			ec.Error(ctx, ec.Recover(ctx, r))
 6504			ret = graphql.Null
 6505		}
 6506	}()
 6507	fc := &graphql.FieldContext{
 6508		Object:   "LabelChangeTimelineItem",
 6509		Field:    field,
 6510		Args:     nil,
 6511		IsMethod: false,
 6512	}
 6513
 6514	ctx = graphql.WithFieldContext(ctx, fc)
 6515	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6516		ctx = rctx // use context from middleware stack in children
 6517		return obj.Removed, nil
 6518	})
 6519	if err != nil {
 6520		ec.Error(ctx, err)
 6521		return graphql.Null
 6522	}
 6523	if resTmp == nil {
 6524		if !graphql.HasFieldError(ctx, fc) {
 6525			ec.Errorf(ctx, "must not be null")
 6526		}
 6527		return graphql.Null
 6528	}
 6529	res := resTmp.([]bug.Label)
 6530	fc.Result = res
 6531	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6532}
 6533
 6534func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6535	defer func() {
 6536		if r := recover(); r != nil {
 6537			ec.Error(ctx, ec.Recover(ctx, r))
 6538			ret = graphql.Null
 6539		}
 6540	}()
 6541	fc := &graphql.FieldContext{
 6542		Object:   "LabelConnection",
 6543		Field:    field,
 6544		Args:     nil,
 6545		IsMethod: false,
 6546	}
 6547
 6548	ctx = graphql.WithFieldContext(ctx, fc)
 6549	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6550		ctx = rctx // use context from middleware stack in children
 6551		return obj.Edges, nil
 6552	})
 6553	if err != nil {
 6554		ec.Error(ctx, err)
 6555		return graphql.Null
 6556	}
 6557	if resTmp == nil {
 6558		if !graphql.HasFieldError(ctx, fc) {
 6559			ec.Errorf(ctx, "must not be null")
 6560		}
 6561		return graphql.Null
 6562	}
 6563	res := resTmp.([]*models.LabelEdge)
 6564	fc.Result = res
 6565	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 6566}
 6567
 6568func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6569	defer func() {
 6570		if r := recover(); r != nil {
 6571			ec.Error(ctx, ec.Recover(ctx, r))
 6572			ret = graphql.Null
 6573		}
 6574	}()
 6575	fc := &graphql.FieldContext{
 6576		Object:   "LabelConnection",
 6577		Field:    field,
 6578		Args:     nil,
 6579		IsMethod: false,
 6580	}
 6581
 6582	ctx = graphql.WithFieldContext(ctx, fc)
 6583	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6584		ctx = rctx // use context from middleware stack in children
 6585		return obj.Nodes, nil
 6586	})
 6587	if err != nil {
 6588		ec.Error(ctx, err)
 6589		return graphql.Null
 6590	}
 6591	if resTmp == nil {
 6592		if !graphql.HasFieldError(ctx, fc) {
 6593			ec.Errorf(ctx, "must not be null")
 6594		}
 6595		return graphql.Null
 6596	}
 6597	res := resTmp.([]bug.Label)
 6598	fc.Result = res
 6599	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6600}
 6601
 6602func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6603	defer func() {
 6604		if r := recover(); r != nil {
 6605			ec.Error(ctx, ec.Recover(ctx, r))
 6606			ret = graphql.Null
 6607		}
 6608	}()
 6609	fc := &graphql.FieldContext{
 6610		Object:   "LabelConnection",
 6611		Field:    field,
 6612		Args:     nil,
 6613		IsMethod: false,
 6614	}
 6615
 6616	ctx = graphql.WithFieldContext(ctx, fc)
 6617	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6618		ctx = rctx // use context from middleware stack in children
 6619		return obj.PageInfo, nil
 6620	})
 6621	if err != nil {
 6622		ec.Error(ctx, err)
 6623		return graphql.Null
 6624	}
 6625	if resTmp == nil {
 6626		if !graphql.HasFieldError(ctx, fc) {
 6627			ec.Errorf(ctx, "must not be null")
 6628		}
 6629		return graphql.Null
 6630	}
 6631	res := resTmp.(*models.PageInfo)
 6632	fc.Result = res
 6633	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6634}
 6635
 6636func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6637	defer func() {
 6638		if r := recover(); r != nil {
 6639			ec.Error(ctx, ec.Recover(ctx, r))
 6640			ret = graphql.Null
 6641		}
 6642	}()
 6643	fc := &graphql.FieldContext{
 6644		Object:   "LabelConnection",
 6645		Field:    field,
 6646		Args:     nil,
 6647		IsMethod: false,
 6648	}
 6649
 6650	ctx = graphql.WithFieldContext(ctx, fc)
 6651	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6652		ctx = rctx // use context from middleware stack in children
 6653		return obj.TotalCount, nil
 6654	})
 6655	if err != nil {
 6656		ec.Error(ctx, err)
 6657		return graphql.Null
 6658	}
 6659	if resTmp == nil {
 6660		if !graphql.HasFieldError(ctx, fc) {
 6661			ec.Errorf(ctx, "must not be null")
 6662		}
 6663		return graphql.Null
 6664	}
 6665	res := resTmp.(int)
 6666	fc.Result = res
 6667	return ec.marshalNInt2int(ctx, field.Selections, res)
 6668}
 6669
 6670func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6671	defer func() {
 6672		if r := recover(); r != nil {
 6673			ec.Error(ctx, ec.Recover(ctx, r))
 6674			ret = graphql.Null
 6675		}
 6676	}()
 6677	fc := &graphql.FieldContext{
 6678		Object:   "LabelEdge",
 6679		Field:    field,
 6680		Args:     nil,
 6681		IsMethod: false,
 6682	}
 6683
 6684	ctx = graphql.WithFieldContext(ctx, fc)
 6685	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6686		ctx = rctx // use context from middleware stack in children
 6687		return obj.Cursor, nil
 6688	})
 6689	if err != nil {
 6690		ec.Error(ctx, err)
 6691		return graphql.Null
 6692	}
 6693	if resTmp == nil {
 6694		if !graphql.HasFieldError(ctx, fc) {
 6695			ec.Errorf(ctx, "must not be null")
 6696		}
 6697		return graphql.Null
 6698	}
 6699	res := resTmp.(string)
 6700	fc.Result = res
 6701	return ec.marshalNString2string(ctx, field.Selections, res)
 6702}
 6703
 6704func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6705	defer func() {
 6706		if r := recover(); r != nil {
 6707			ec.Error(ctx, ec.Recover(ctx, r))
 6708			ret = graphql.Null
 6709		}
 6710	}()
 6711	fc := &graphql.FieldContext{
 6712		Object:   "LabelEdge",
 6713		Field:    field,
 6714		Args:     nil,
 6715		IsMethod: false,
 6716	}
 6717
 6718	ctx = graphql.WithFieldContext(ctx, fc)
 6719	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6720		ctx = rctx // use context from middleware stack in children
 6721		return obj.Node, nil
 6722	})
 6723	if err != nil {
 6724		ec.Error(ctx, err)
 6725		return graphql.Null
 6726	}
 6727	if resTmp == nil {
 6728		if !graphql.HasFieldError(ctx, fc) {
 6729			ec.Errorf(ctx, "must not be null")
 6730		}
 6731		return graphql.Null
 6732	}
 6733	res := resTmp.(bug.Label)
 6734	fc.Result = res
 6735	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6736}
 6737
 6738func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6739	defer func() {
 6740		if r := recover(); r != nil {
 6741			ec.Error(ctx, ec.Recover(ctx, r))
 6742			ret = graphql.Null
 6743		}
 6744	}()
 6745	fc := &graphql.FieldContext{
 6746		Object:   "Mutation",
 6747		Field:    field,
 6748		Args:     nil,
 6749		IsMethod: true,
 6750	}
 6751
 6752	ctx = graphql.WithFieldContext(ctx, fc)
 6753	rawArgs := field.ArgumentMap(ec.Variables)
 6754	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6755	if err != nil {
 6756		ec.Error(ctx, err)
 6757		return graphql.Null
 6758	}
 6759	fc.Args = args
 6760	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6761		ctx = rctx // use context from middleware stack in children
 6762		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 6763	})
 6764	if err != nil {
 6765		ec.Error(ctx, err)
 6766		return graphql.Null
 6767	}
 6768	if resTmp == nil {
 6769		if !graphql.HasFieldError(ctx, fc) {
 6770			ec.Errorf(ctx, "must not be null")
 6771		}
 6772		return graphql.Null
 6773	}
 6774	res := resTmp.(*models.NewBugPayload)
 6775	fc.Result = res
 6776	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 6777}
 6778
 6779func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6780	defer func() {
 6781		if r := recover(); r != nil {
 6782			ec.Error(ctx, ec.Recover(ctx, r))
 6783			ret = graphql.Null
 6784		}
 6785	}()
 6786	fc := &graphql.FieldContext{
 6787		Object:   "Mutation",
 6788		Field:    field,
 6789		Args:     nil,
 6790		IsMethod: true,
 6791	}
 6792
 6793	ctx = graphql.WithFieldContext(ctx, fc)
 6794	rawArgs := field.ArgumentMap(ec.Variables)
 6795	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 6796	if err != nil {
 6797		ec.Error(ctx, err)
 6798		return graphql.Null
 6799	}
 6800	fc.Args = args
 6801	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6802		ctx = rctx // use context from middleware stack in children
 6803		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 6804	})
 6805	if err != nil {
 6806		ec.Error(ctx, err)
 6807		return graphql.Null
 6808	}
 6809	if resTmp == nil {
 6810		if !graphql.HasFieldError(ctx, fc) {
 6811			ec.Errorf(ctx, "must not be null")
 6812		}
 6813		return graphql.Null
 6814	}
 6815	res := resTmp.(*models.AddCommentPayload)
 6816	fc.Result = res
 6817	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 6818}
 6819
 6820func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6821	defer func() {
 6822		if r := recover(); r != nil {
 6823			ec.Error(ctx, ec.Recover(ctx, r))
 6824			ret = graphql.Null
 6825		}
 6826	}()
 6827	fc := &graphql.FieldContext{
 6828		Object:   "Mutation",
 6829		Field:    field,
 6830		Args:     nil,
 6831		IsMethod: true,
 6832	}
 6833
 6834	ctx = graphql.WithFieldContext(ctx, fc)
 6835	rawArgs := field.ArgumentMap(ec.Variables)
 6836	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 6837	if err != nil {
 6838		ec.Error(ctx, err)
 6839		return graphql.Null
 6840	}
 6841	fc.Args = args
 6842	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6843		ctx = rctx // use context from middleware stack in children
 6844		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 6845	})
 6846	if err != nil {
 6847		ec.Error(ctx, err)
 6848		return graphql.Null
 6849	}
 6850	if resTmp == nil {
 6851		if !graphql.HasFieldError(ctx, fc) {
 6852			ec.Errorf(ctx, "must not be null")
 6853		}
 6854		return graphql.Null
 6855	}
 6856	res := resTmp.(*models.ChangeLabelPayload)
 6857	fc.Result = res
 6858	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 6859}
 6860
 6861func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6862	defer func() {
 6863		if r := recover(); r != nil {
 6864			ec.Error(ctx, ec.Recover(ctx, r))
 6865			ret = graphql.Null
 6866		}
 6867	}()
 6868	fc := &graphql.FieldContext{
 6869		Object:   "Mutation",
 6870		Field:    field,
 6871		Args:     nil,
 6872		IsMethod: true,
 6873	}
 6874
 6875	ctx = graphql.WithFieldContext(ctx, fc)
 6876	rawArgs := field.ArgumentMap(ec.Variables)
 6877	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 6878	if err != nil {
 6879		ec.Error(ctx, err)
 6880		return graphql.Null
 6881	}
 6882	fc.Args = args
 6883	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6884		ctx = rctx // use context from middleware stack in children
 6885		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 6886	})
 6887	if err != nil {
 6888		ec.Error(ctx, err)
 6889		return graphql.Null
 6890	}
 6891	if resTmp == nil {
 6892		if !graphql.HasFieldError(ctx, fc) {
 6893			ec.Errorf(ctx, "must not be null")
 6894		}
 6895		return graphql.Null
 6896	}
 6897	res := resTmp.(*models.OpenBugPayload)
 6898	fc.Result = res
 6899	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 6900}
 6901
 6902func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6903	defer func() {
 6904		if r := recover(); r != nil {
 6905			ec.Error(ctx, ec.Recover(ctx, r))
 6906			ret = graphql.Null
 6907		}
 6908	}()
 6909	fc := &graphql.FieldContext{
 6910		Object:   "Mutation",
 6911		Field:    field,
 6912		Args:     nil,
 6913		IsMethod: true,
 6914	}
 6915
 6916	ctx = graphql.WithFieldContext(ctx, fc)
 6917	rawArgs := field.ArgumentMap(ec.Variables)
 6918	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 6919	if err != nil {
 6920		ec.Error(ctx, err)
 6921		return graphql.Null
 6922	}
 6923	fc.Args = args
 6924	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6925		ctx = rctx // use context from middleware stack in children
 6926		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 6927	})
 6928	if err != nil {
 6929		ec.Error(ctx, err)
 6930		return graphql.Null
 6931	}
 6932	if resTmp == nil {
 6933		if !graphql.HasFieldError(ctx, fc) {
 6934			ec.Errorf(ctx, "must not be null")
 6935		}
 6936		return graphql.Null
 6937	}
 6938	res := resTmp.(*models.CloseBugPayload)
 6939	fc.Result = res
 6940	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 6941}
 6942
 6943func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6944	defer func() {
 6945		if r := recover(); r != nil {
 6946			ec.Error(ctx, ec.Recover(ctx, r))
 6947			ret = graphql.Null
 6948		}
 6949	}()
 6950	fc := &graphql.FieldContext{
 6951		Object:   "Mutation",
 6952		Field:    field,
 6953		Args:     nil,
 6954		IsMethod: true,
 6955	}
 6956
 6957	ctx = graphql.WithFieldContext(ctx, fc)
 6958	rawArgs := field.ArgumentMap(ec.Variables)
 6959	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 6960	if err != nil {
 6961		ec.Error(ctx, err)
 6962		return graphql.Null
 6963	}
 6964	fc.Args = args
 6965	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6966		ctx = rctx // use context from middleware stack in children
 6967		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 6968	})
 6969	if err != nil {
 6970		ec.Error(ctx, err)
 6971		return graphql.Null
 6972	}
 6973	if resTmp == nil {
 6974		if !graphql.HasFieldError(ctx, fc) {
 6975			ec.Errorf(ctx, "must not be null")
 6976		}
 6977		return graphql.Null
 6978	}
 6979	res := resTmp.(*models.SetTitlePayload)
 6980	fc.Result = res
 6981	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 6982}
 6983
 6984func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 6985	defer func() {
 6986		if r := recover(); r != nil {
 6987			ec.Error(ctx, ec.Recover(ctx, r))
 6988			ret = graphql.Null
 6989		}
 6990	}()
 6991	fc := &graphql.FieldContext{
 6992		Object:   "NewBugPayload",
 6993		Field:    field,
 6994		Args:     nil,
 6995		IsMethod: false,
 6996	}
 6997
 6998	ctx = graphql.WithFieldContext(ctx, fc)
 6999	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7000		ctx = rctx // use context from middleware stack in children
 7001		return obj.ClientMutationID, nil
 7002	})
 7003	if err != nil {
 7004		ec.Error(ctx, err)
 7005		return graphql.Null
 7006	}
 7007	if resTmp == nil {
 7008		return graphql.Null
 7009	}
 7010	res := resTmp.(*string)
 7011	fc.Result = res
 7012	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7013}
 7014
 7015func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7016	defer func() {
 7017		if r := recover(); r != nil {
 7018			ec.Error(ctx, ec.Recover(ctx, r))
 7019			ret = graphql.Null
 7020		}
 7021	}()
 7022	fc := &graphql.FieldContext{
 7023		Object:   "NewBugPayload",
 7024		Field:    field,
 7025		Args:     nil,
 7026		IsMethod: false,
 7027	}
 7028
 7029	ctx = graphql.WithFieldContext(ctx, fc)
 7030	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7031		ctx = rctx // use context from middleware stack in children
 7032		return obj.Bug, nil
 7033	})
 7034	if err != nil {
 7035		ec.Error(ctx, err)
 7036		return graphql.Null
 7037	}
 7038	if resTmp == nil {
 7039		if !graphql.HasFieldError(ctx, fc) {
 7040			ec.Errorf(ctx, "must not be null")
 7041		}
 7042		return graphql.Null
 7043	}
 7044	res := resTmp.(models.BugWrapper)
 7045	fc.Result = res
 7046	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7047}
 7048
 7049func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7050	defer func() {
 7051		if r := recover(); r != nil {
 7052			ec.Error(ctx, ec.Recover(ctx, r))
 7053			ret = graphql.Null
 7054		}
 7055	}()
 7056	fc := &graphql.FieldContext{
 7057		Object:   "NewBugPayload",
 7058		Field:    field,
 7059		Args:     nil,
 7060		IsMethod: false,
 7061	}
 7062
 7063	ctx = graphql.WithFieldContext(ctx, fc)
 7064	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7065		ctx = rctx // use context from middleware stack in children
 7066		return obj.Operation, nil
 7067	})
 7068	if err != nil {
 7069		ec.Error(ctx, err)
 7070		return graphql.Null
 7071	}
 7072	if resTmp == nil {
 7073		if !graphql.HasFieldError(ctx, fc) {
 7074			ec.Errorf(ctx, "must not be null")
 7075		}
 7076		return graphql.Null
 7077	}
 7078	res := resTmp.(*bug.CreateOperation)
 7079	fc.Result = res
 7080	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7081}
 7082
 7083func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7084	defer func() {
 7085		if r := recover(); r != nil {
 7086			ec.Error(ctx, ec.Recover(ctx, r))
 7087			ret = graphql.Null
 7088		}
 7089	}()
 7090	fc := &graphql.FieldContext{
 7091		Object:   "OpenBugPayload",
 7092		Field:    field,
 7093		Args:     nil,
 7094		IsMethod: false,
 7095	}
 7096
 7097	ctx = graphql.WithFieldContext(ctx, fc)
 7098	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7099		ctx = rctx // use context from middleware stack in children
 7100		return obj.ClientMutationID, nil
 7101	})
 7102	if err != nil {
 7103		ec.Error(ctx, err)
 7104		return graphql.Null
 7105	}
 7106	if resTmp == nil {
 7107		return graphql.Null
 7108	}
 7109	res := resTmp.(*string)
 7110	fc.Result = res
 7111	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7112}
 7113
 7114func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7115	defer func() {
 7116		if r := recover(); r != nil {
 7117			ec.Error(ctx, ec.Recover(ctx, r))
 7118			ret = graphql.Null
 7119		}
 7120	}()
 7121	fc := &graphql.FieldContext{
 7122		Object:   "OpenBugPayload",
 7123		Field:    field,
 7124		Args:     nil,
 7125		IsMethod: false,
 7126	}
 7127
 7128	ctx = graphql.WithFieldContext(ctx, fc)
 7129	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7130		ctx = rctx // use context from middleware stack in children
 7131		return obj.Bug, nil
 7132	})
 7133	if err != nil {
 7134		ec.Error(ctx, err)
 7135		return graphql.Null
 7136	}
 7137	if resTmp == nil {
 7138		if !graphql.HasFieldError(ctx, fc) {
 7139			ec.Errorf(ctx, "must not be null")
 7140		}
 7141		return graphql.Null
 7142	}
 7143	res := resTmp.(models.BugWrapper)
 7144	fc.Result = res
 7145	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7146}
 7147
 7148func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7149	defer func() {
 7150		if r := recover(); r != nil {
 7151			ec.Error(ctx, ec.Recover(ctx, r))
 7152			ret = graphql.Null
 7153		}
 7154	}()
 7155	fc := &graphql.FieldContext{
 7156		Object:   "OpenBugPayload",
 7157		Field:    field,
 7158		Args:     nil,
 7159		IsMethod: false,
 7160	}
 7161
 7162	ctx = graphql.WithFieldContext(ctx, fc)
 7163	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7164		ctx = rctx // use context from middleware stack in children
 7165		return obj.Operation, nil
 7166	})
 7167	if err != nil {
 7168		ec.Error(ctx, err)
 7169		return graphql.Null
 7170	}
 7171	if resTmp == nil {
 7172		if !graphql.HasFieldError(ctx, fc) {
 7173			ec.Errorf(ctx, "must not be null")
 7174		}
 7175		return graphql.Null
 7176	}
 7177	res := resTmp.(*bug.SetStatusOperation)
 7178	fc.Result = res
 7179	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7180}
 7181
 7182func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7183	defer func() {
 7184		if r := recover(); r != nil {
 7185			ec.Error(ctx, ec.Recover(ctx, r))
 7186			ret = graphql.Null
 7187		}
 7188	}()
 7189	fc := &graphql.FieldContext{
 7190		Object:   "OperationConnection",
 7191		Field:    field,
 7192		Args:     nil,
 7193		IsMethod: false,
 7194	}
 7195
 7196	ctx = graphql.WithFieldContext(ctx, fc)
 7197	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7198		ctx = rctx // use context from middleware stack in children
 7199		return obj.Edges, nil
 7200	})
 7201	if err != nil {
 7202		ec.Error(ctx, err)
 7203		return graphql.Null
 7204	}
 7205	if resTmp == nil {
 7206		if !graphql.HasFieldError(ctx, fc) {
 7207			ec.Errorf(ctx, "must not be null")
 7208		}
 7209		return graphql.Null
 7210	}
 7211	res := resTmp.([]*models.OperationEdge)
 7212	fc.Result = res
 7213	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7214}
 7215
 7216func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7217	defer func() {
 7218		if r := recover(); r != nil {
 7219			ec.Error(ctx, ec.Recover(ctx, r))
 7220			ret = graphql.Null
 7221		}
 7222	}()
 7223	fc := &graphql.FieldContext{
 7224		Object:   "OperationConnection",
 7225		Field:    field,
 7226		Args:     nil,
 7227		IsMethod: false,
 7228	}
 7229
 7230	ctx = graphql.WithFieldContext(ctx, fc)
 7231	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7232		ctx = rctx // use context from middleware stack in children
 7233		return obj.Nodes, nil
 7234	})
 7235	if err != nil {
 7236		ec.Error(ctx, err)
 7237		return graphql.Null
 7238	}
 7239	if resTmp == nil {
 7240		if !graphql.HasFieldError(ctx, fc) {
 7241			ec.Errorf(ctx, "must not be null")
 7242		}
 7243		return graphql.Null
 7244	}
 7245	res := resTmp.([]bug.Operation)
 7246	fc.Result = res
 7247	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7248}
 7249
 7250func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7251	defer func() {
 7252		if r := recover(); r != nil {
 7253			ec.Error(ctx, ec.Recover(ctx, r))
 7254			ret = graphql.Null
 7255		}
 7256	}()
 7257	fc := &graphql.FieldContext{
 7258		Object:   "OperationConnection",
 7259		Field:    field,
 7260		Args:     nil,
 7261		IsMethod: false,
 7262	}
 7263
 7264	ctx = graphql.WithFieldContext(ctx, fc)
 7265	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7266		ctx = rctx // use context from middleware stack in children
 7267		return obj.PageInfo, nil
 7268	})
 7269	if err != nil {
 7270		ec.Error(ctx, err)
 7271		return graphql.Null
 7272	}
 7273	if resTmp == nil {
 7274		if !graphql.HasFieldError(ctx, fc) {
 7275			ec.Errorf(ctx, "must not be null")
 7276		}
 7277		return graphql.Null
 7278	}
 7279	res := resTmp.(*models.PageInfo)
 7280	fc.Result = res
 7281	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7282}
 7283
 7284func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7285	defer func() {
 7286		if r := recover(); r != nil {
 7287			ec.Error(ctx, ec.Recover(ctx, r))
 7288			ret = graphql.Null
 7289		}
 7290	}()
 7291	fc := &graphql.FieldContext{
 7292		Object:   "OperationConnection",
 7293		Field:    field,
 7294		Args:     nil,
 7295		IsMethod: false,
 7296	}
 7297
 7298	ctx = graphql.WithFieldContext(ctx, fc)
 7299	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7300		ctx = rctx // use context from middleware stack in children
 7301		return obj.TotalCount, nil
 7302	})
 7303	if err != nil {
 7304		ec.Error(ctx, err)
 7305		return graphql.Null
 7306	}
 7307	if resTmp == nil {
 7308		if !graphql.HasFieldError(ctx, fc) {
 7309			ec.Errorf(ctx, "must not be null")
 7310		}
 7311		return graphql.Null
 7312	}
 7313	res := resTmp.(int)
 7314	fc.Result = res
 7315	return ec.marshalNInt2int(ctx, field.Selections, res)
 7316}
 7317
 7318func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7319	defer func() {
 7320		if r := recover(); r != nil {
 7321			ec.Error(ctx, ec.Recover(ctx, r))
 7322			ret = graphql.Null
 7323		}
 7324	}()
 7325	fc := &graphql.FieldContext{
 7326		Object:   "OperationEdge",
 7327		Field:    field,
 7328		Args:     nil,
 7329		IsMethod: false,
 7330	}
 7331
 7332	ctx = graphql.WithFieldContext(ctx, fc)
 7333	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7334		ctx = rctx // use context from middleware stack in children
 7335		return obj.Cursor, nil
 7336	})
 7337	if err != nil {
 7338		ec.Error(ctx, err)
 7339		return graphql.Null
 7340	}
 7341	if resTmp == nil {
 7342		if !graphql.HasFieldError(ctx, fc) {
 7343			ec.Errorf(ctx, "must not be null")
 7344		}
 7345		return graphql.Null
 7346	}
 7347	res := resTmp.(string)
 7348	fc.Result = res
 7349	return ec.marshalNString2string(ctx, field.Selections, res)
 7350}
 7351
 7352func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7353	defer func() {
 7354		if r := recover(); r != nil {
 7355			ec.Error(ctx, ec.Recover(ctx, r))
 7356			ret = graphql.Null
 7357		}
 7358	}()
 7359	fc := &graphql.FieldContext{
 7360		Object:   "OperationEdge",
 7361		Field:    field,
 7362		Args:     nil,
 7363		IsMethod: false,
 7364	}
 7365
 7366	ctx = graphql.WithFieldContext(ctx, fc)
 7367	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7368		ctx = rctx // use context from middleware stack in children
 7369		return obj.Node, nil
 7370	})
 7371	if err != nil {
 7372		ec.Error(ctx, err)
 7373		return graphql.Null
 7374	}
 7375	if resTmp == nil {
 7376		if !graphql.HasFieldError(ctx, fc) {
 7377			ec.Errorf(ctx, "must not be null")
 7378		}
 7379		return graphql.Null
 7380	}
 7381	res := resTmp.(bug.Operation)
 7382	fc.Result = res
 7383	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7384}
 7385
 7386func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7387	defer func() {
 7388		if r := recover(); r != nil {
 7389			ec.Error(ctx, ec.Recover(ctx, r))
 7390			ret = graphql.Null
 7391		}
 7392	}()
 7393	fc := &graphql.FieldContext{
 7394		Object:   "PageInfo",
 7395		Field:    field,
 7396		Args:     nil,
 7397		IsMethod: false,
 7398	}
 7399
 7400	ctx = graphql.WithFieldContext(ctx, fc)
 7401	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7402		ctx = rctx // use context from middleware stack in children
 7403		return obj.HasNextPage, nil
 7404	})
 7405	if err != nil {
 7406		ec.Error(ctx, err)
 7407		return graphql.Null
 7408	}
 7409	if resTmp == nil {
 7410		if !graphql.HasFieldError(ctx, fc) {
 7411			ec.Errorf(ctx, "must not be null")
 7412		}
 7413		return graphql.Null
 7414	}
 7415	res := resTmp.(bool)
 7416	fc.Result = res
 7417	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7418}
 7419
 7420func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7421	defer func() {
 7422		if r := recover(); r != nil {
 7423			ec.Error(ctx, ec.Recover(ctx, r))
 7424			ret = graphql.Null
 7425		}
 7426	}()
 7427	fc := &graphql.FieldContext{
 7428		Object:   "PageInfo",
 7429		Field:    field,
 7430		Args:     nil,
 7431		IsMethod: false,
 7432	}
 7433
 7434	ctx = graphql.WithFieldContext(ctx, fc)
 7435	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7436		ctx = rctx // use context from middleware stack in children
 7437		return obj.HasPreviousPage, nil
 7438	})
 7439	if err != nil {
 7440		ec.Error(ctx, err)
 7441		return graphql.Null
 7442	}
 7443	if resTmp == nil {
 7444		if !graphql.HasFieldError(ctx, fc) {
 7445			ec.Errorf(ctx, "must not be null")
 7446		}
 7447		return graphql.Null
 7448	}
 7449	res := resTmp.(bool)
 7450	fc.Result = res
 7451	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7452}
 7453
 7454func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7455	defer func() {
 7456		if r := recover(); r != nil {
 7457			ec.Error(ctx, ec.Recover(ctx, r))
 7458			ret = graphql.Null
 7459		}
 7460	}()
 7461	fc := &graphql.FieldContext{
 7462		Object:   "PageInfo",
 7463		Field:    field,
 7464		Args:     nil,
 7465		IsMethod: false,
 7466	}
 7467
 7468	ctx = graphql.WithFieldContext(ctx, fc)
 7469	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7470		ctx = rctx // use context from middleware stack in children
 7471		return obj.StartCursor, nil
 7472	})
 7473	if err != nil {
 7474		ec.Error(ctx, err)
 7475		return graphql.Null
 7476	}
 7477	if resTmp == nil {
 7478		if !graphql.HasFieldError(ctx, fc) {
 7479			ec.Errorf(ctx, "must not be null")
 7480		}
 7481		return graphql.Null
 7482	}
 7483	res := resTmp.(string)
 7484	fc.Result = res
 7485	return ec.marshalNString2string(ctx, field.Selections, res)
 7486}
 7487
 7488func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7489	defer func() {
 7490		if r := recover(); r != nil {
 7491			ec.Error(ctx, ec.Recover(ctx, r))
 7492			ret = graphql.Null
 7493		}
 7494	}()
 7495	fc := &graphql.FieldContext{
 7496		Object:   "PageInfo",
 7497		Field:    field,
 7498		Args:     nil,
 7499		IsMethod: false,
 7500	}
 7501
 7502	ctx = graphql.WithFieldContext(ctx, fc)
 7503	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7504		ctx = rctx // use context from middleware stack in children
 7505		return obj.EndCursor, nil
 7506	})
 7507	if err != nil {
 7508		ec.Error(ctx, err)
 7509		return graphql.Null
 7510	}
 7511	if resTmp == nil {
 7512		if !graphql.HasFieldError(ctx, fc) {
 7513			ec.Errorf(ctx, "must not be null")
 7514		}
 7515		return graphql.Null
 7516	}
 7517	res := resTmp.(string)
 7518	fc.Result = res
 7519	return ec.marshalNString2string(ctx, field.Selections, res)
 7520}
 7521
 7522func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7523	defer func() {
 7524		if r := recover(); r != nil {
 7525			ec.Error(ctx, ec.Recover(ctx, r))
 7526			ret = graphql.Null
 7527		}
 7528	}()
 7529	fc := &graphql.FieldContext{
 7530		Object:   "Query",
 7531		Field:    field,
 7532		Args:     nil,
 7533		IsMethod: true,
 7534	}
 7535
 7536	ctx = graphql.WithFieldContext(ctx, fc)
 7537	rawArgs := field.ArgumentMap(ec.Variables)
 7538	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7539	if err != nil {
 7540		ec.Error(ctx, err)
 7541		return graphql.Null
 7542	}
 7543	fc.Args = args
 7544	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7545		ctx = rctx // use context from middleware stack in children
 7546		return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
 7547	})
 7548	if err != nil {
 7549		ec.Error(ctx, err)
 7550		return graphql.Null
 7551	}
 7552	if resTmp == nil {
 7553		return graphql.Null
 7554	}
 7555	res := resTmp.(*models.Repository)
 7556	fc.Result = res
 7557	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7558}
 7559
 7560func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7561	defer func() {
 7562		if r := recover(); r != nil {
 7563			ec.Error(ctx, ec.Recover(ctx, r))
 7564			ret = graphql.Null
 7565		}
 7566	}()
 7567	fc := &graphql.FieldContext{
 7568		Object:   "Query",
 7569		Field:    field,
 7570		Args:     nil,
 7571		IsMethod: true,
 7572	}
 7573
 7574	ctx = graphql.WithFieldContext(ctx, fc)
 7575	rawArgs := field.ArgumentMap(ec.Variables)
 7576	args, err := ec.field_Query___type_args(ctx, rawArgs)
 7577	if err != nil {
 7578		ec.Error(ctx, err)
 7579		return graphql.Null
 7580	}
 7581	fc.Args = args
 7582	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7583		ctx = rctx // use context from middleware stack in children
 7584		return ec.introspectType(args["name"].(string))
 7585	})
 7586	if err != nil {
 7587		ec.Error(ctx, err)
 7588		return graphql.Null
 7589	}
 7590	if resTmp == nil {
 7591		return graphql.Null
 7592	}
 7593	res := resTmp.(*introspection.Type)
 7594	fc.Result = res
 7595	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7596}
 7597
 7598func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7599	defer func() {
 7600		if r := recover(); r != nil {
 7601			ec.Error(ctx, ec.Recover(ctx, r))
 7602			ret = graphql.Null
 7603		}
 7604	}()
 7605	fc := &graphql.FieldContext{
 7606		Object:   "Query",
 7607		Field:    field,
 7608		Args:     nil,
 7609		IsMethod: true,
 7610	}
 7611
 7612	ctx = graphql.WithFieldContext(ctx, fc)
 7613	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7614		ctx = rctx // use context from middleware stack in children
 7615		return ec.introspectSchema()
 7616	})
 7617	if err != nil {
 7618		ec.Error(ctx, err)
 7619		return graphql.Null
 7620	}
 7621	if resTmp == nil {
 7622		return graphql.Null
 7623	}
 7624	res := resTmp.(*introspection.Schema)
 7625	fc.Result = res
 7626	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 7627}
 7628
 7629func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7630	defer func() {
 7631		if r := recover(); r != nil {
 7632			ec.Error(ctx, ec.Recover(ctx, r))
 7633			ret = graphql.Null
 7634		}
 7635	}()
 7636	fc := &graphql.FieldContext{
 7637		Object:   "Repository",
 7638		Field:    field,
 7639		Args:     nil,
 7640		IsMethod: true,
 7641	}
 7642
 7643	ctx = graphql.WithFieldContext(ctx, fc)
 7644	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7645		ctx = rctx // use context from middleware stack in children
 7646		return ec.resolvers.Repository().Name(rctx, obj)
 7647	})
 7648	if err != nil {
 7649		ec.Error(ctx, err)
 7650		return graphql.Null
 7651	}
 7652	if resTmp == nil {
 7653		return graphql.Null
 7654	}
 7655	res := resTmp.(*string)
 7656	fc.Result = res
 7657	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7658}
 7659
 7660func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7661	defer func() {
 7662		if r := recover(); r != nil {
 7663			ec.Error(ctx, ec.Recover(ctx, r))
 7664			ret = graphql.Null
 7665		}
 7666	}()
 7667	fc := &graphql.FieldContext{
 7668		Object:   "Repository",
 7669		Field:    field,
 7670		Args:     nil,
 7671		IsMethod: true,
 7672	}
 7673
 7674	ctx = graphql.WithFieldContext(ctx, fc)
 7675	rawArgs := field.ArgumentMap(ec.Variables)
 7676	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 7677	if err != nil {
 7678		ec.Error(ctx, err)
 7679		return graphql.Null
 7680	}
 7681	fc.Args = args
 7682	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7683		ctx = rctx // use context from middleware stack in children
 7684		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 7685	})
 7686	if err != nil {
 7687		ec.Error(ctx, err)
 7688		return graphql.Null
 7689	}
 7690	if resTmp == nil {
 7691		if !graphql.HasFieldError(ctx, fc) {
 7692			ec.Errorf(ctx, "must not be null")
 7693		}
 7694		return graphql.Null
 7695	}
 7696	res := resTmp.(*models.BugConnection)
 7697	fc.Result = res
 7698	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 7699}
 7700
 7701func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7702	defer func() {
 7703		if r := recover(); r != nil {
 7704			ec.Error(ctx, ec.Recover(ctx, r))
 7705			ret = graphql.Null
 7706		}
 7707	}()
 7708	fc := &graphql.FieldContext{
 7709		Object:   "Repository",
 7710		Field:    field,
 7711		Args:     nil,
 7712		IsMethod: true,
 7713	}
 7714
 7715	ctx = graphql.WithFieldContext(ctx, fc)
 7716	rawArgs := field.ArgumentMap(ec.Variables)
 7717	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 7718	if err != nil {
 7719		ec.Error(ctx, err)
 7720		return graphql.Null
 7721	}
 7722	fc.Args = args
 7723	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7724		ctx = rctx // use context from middleware stack in children
 7725		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 7726	})
 7727	if err != nil {
 7728		ec.Error(ctx, err)
 7729		return graphql.Null
 7730	}
 7731	if resTmp == nil {
 7732		return graphql.Null
 7733	}
 7734	res := resTmp.(models.BugWrapper)
 7735	fc.Result = res
 7736	return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7737}
 7738
 7739func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7740	defer func() {
 7741		if r := recover(); r != nil {
 7742			ec.Error(ctx, ec.Recover(ctx, r))
 7743			ret = graphql.Null
 7744		}
 7745	}()
 7746	fc := &graphql.FieldContext{
 7747		Object:   "Repository",
 7748		Field:    field,
 7749		Args:     nil,
 7750		IsMethod: true,
 7751	}
 7752
 7753	ctx = graphql.WithFieldContext(ctx, fc)
 7754	rawArgs := field.ArgumentMap(ec.Variables)
 7755	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 7756	if err != nil {
 7757		ec.Error(ctx, err)
 7758		return graphql.Null
 7759	}
 7760	fc.Args = args
 7761	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7762		ctx = rctx // use context from middleware stack in children
 7763		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7764	})
 7765	if err != nil {
 7766		ec.Error(ctx, err)
 7767		return graphql.Null
 7768	}
 7769	if resTmp == nil {
 7770		if !graphql.HasFieldError(ctx, fc) {
 7771			ec.Errorf(ctx, "must not be null")
 7772		}
 7773		return graphql.Null
 7774	}
 7775	res := resTmp.(*models.IdentityConnection)
 7776	fc.Result = res
 7777	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 7778}
 7779
 7780func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7781	defer func() {
 7782		if r := recover(); r != nil {
 7783			ec.Error(ctx, ec.Recover(ctx, r))
 7784			ret = graphql.Null
 7785		}
 7786	}()
 7787	fc := &graphql.FieldContext{
 7788		Object:   "Repository",
 7789		Field:    field,
 7790		Args:     nil,
 7791		IsMethod: true,
 7792	}
 7793
 7794	ctx = graphql.WithFieldContext(ctx, fc)
 7795	rawArgs := field.ArgumentMap(ec.Variables)
 7796	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 7797	if err != nil {
 7798		ec.Error(ctx, err)
 7799		return graphql.Null
 7800	}
 7801	fc.Args = args
 7802	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7803		ctx = rctx // use context from middleware stack in children
 7804		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 7805	})
 7806	if err != nil {
 7807		ec.Error(ctx, err)
 7808		return graphql.Null
 7809	}
 7810	if resTmp == nil {
 7811		return graphql.Null
 7812	}
 7813	res := resTmp.(models.IdentityWrapper)
 7814	fc.Result = res
 7815	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7816}
 7817
 7818func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7819	defer func() {
 7820		if r := recover(); r != nil {
 7821			ec.Error(ctx, ec.Recover(ctx, r))
 7822			ret = graphql.Null
 7823		}
 7824	}()
 7825	fc := &graphql.FieldContext{
 7826		Object:   "Repository",
 7827		Field:    field,
 7828		Args:     nil,
 7829		IsMethod: true,
 7830	}
 7831
 7832	ctx = graphql.WithFieldContext(ctx, fc)
 7833	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7834		ctx = rctx // use context from middleware stack in children
 7835		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 7836	})
 7837	if err != nil {
 7838		ec.Error(ctx, err)
 7839		return graphql.Null
 7840	}
 7841	if resTmp == nil {
 7842		return graphql.Null
 7843	}
 7844	res := resTmp.(models.IdentityWrapper)
 7845	fc.Result = res
 7846	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7847}
 7848
 7849func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7850	defer func() {
 7851		if r := recover(); r != nil {
 7852			ec.Error(ctx, ec.Recover(ctx, r))
 7853			ret = graphql.Null
 7854		}
 7855	}()
 7856	fc := &graphql.FieldContext{
 7857		Object:   "Repository",
 7858		Field:    field,
 7859		Args:     nil,
 7860		IsMethod: true,
 7861	}
 7862
 7863	ctx = graphql.WithFieldContext(ctx, fc)
 7864	rawArgs := field.ArgumentMap(ec.Variables)
 7865	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 7866	if err != nil {
 7867		ec.Error(ctx, err)
 7868		return graphql.Null
 7869	}
 7870	fc.Args = args
 7871	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7872		ctx = rctx // use context from middleware stack in children
 7873		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7874	})
 7875	if err != nil {
 7876		ec.Error(ctx, err)
 7877		return graphql.Null
 7878	}
 7879	if resTmp == nil {
 7880		if !graphql.HasFieldError(ctx, fc) {
 7881			ec.Errorf(ctx, "must not be null")
 7882		}
 7883		return graphql.Null
 7884	}
 7885	res := resTmp.(*models.LabelConnection)
 7886	fc.Result = res
 7887	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 7888}
 7889
 7890func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7891	defer func() {
 7892		if r := recover(); r != nil {
 7893			ec.Error(ctx, ec.Recover(ctx, r))
 7894			ret = graphql.Null
 7895		}
 7896	}()
 7897	fc := &graphql.FieldContext{
 7898		Object:   "SetStatusOperation",
 7899		Field:    field,
 7900		Args:     nil,
 7901		IsMethod: true,
 7902	}
 7903
 7904	ctx = graphql.WithFieldContext(ctx, fc)
 7905	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7906		ctx = rctx // use context from middleware stack in children
 7907		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 7908	})
 7909	if err != nil {
 7910		ec.Error(ctx, err)
 7911		return graphql.Null
 7912	}
 7913	if resTmp == nil {
 7914		if !graphql.HasFieldError(ctx, fc) {
 7915			ec.Errorf(ctx, "must not be null")
 7916		}
 7917		return graphql.Null
 7918	}
 7919	res := resTmp.(string)
 7920	fc.Result = res
 7921	return ec.marshalNString2string(ctx, field.Selections, res)
 7922}
 7923
 7924func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7925	defer func() {
 7926		if r := recover(); r != nil {
 7927			ec.Error(ctx, ec.Recover(ctx, r))
 7928			ret = graphql.Null
 7929		}
 7930	}()
 7931	fc := &graphql.FieldContext{
 7932		Object:   "SetStatusOperation",
 7933		Field:    field,
 7934		Args:     nil,
 7935		IsMethod: true,
 7936	}
 7937
 7938	ctx = graphql.WithFieldContext(ctx, fc)
 7939	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7940		ctx = rctx // use context from middleware stack in children
 7941		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
 7942	})
 7943	if err != nil {
 7944		ec.Error(ctx, err)
 7945		return graphql.Null
 7946	}
 7947	if resTmp == nil {
 7948		if !graphql.HasFieldError(ctx, fc) {
 7949			ec.Errorf(ctx, "must not be null")
 7950		}
 7951		return graphql.Null
 7952	}
 7953	res := resTmp.(models.IdentityWrapper)
 7954	fc.Result = res
 7955	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7956}
 7957
 7958func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7959	defer func() {
 7960		if r := recover(); r != nil {
 7961			ec.Error(ctx, ec.Recover(ctx, r))
 7962			ret = graphql.Null
 7963		}
 7964	}()
 7965	fc := &graphql.FieldContext{
 7966		Object:   "SetStatusOperation",
 7967		Field:    field,
 7968		Args:     nil,
 7969		IsMethod: true,
 7970	}
 7971
 7972	ctx = graphql.WithFieldContext(ctx, fc)
 7973	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7974		ctx = rctx // use context from middleware stack in children
 7975		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 7976	})
 7977	if err != nil {
 7978		ec.Error(ctx, err)
 7979		return graphql.Null
 7980	}
 7981	if resTmp == nil {
 7982		if !graphql.HasFieldError(ctx, fc) {
 7983			ec.Errorf(ctx, "must not be null")
 7984		}
 7985		return graphql.Null
 7986	}
 7987	res := resTmp.(*time.Time)
 7988	fc.Result = res
 7989	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7990}
 7991
 7992func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7993	defer func() {
 7994		if r := recover(); r != nil {
 7995			ec.Error(ctx, ec.Recover(ctx, r))
 7996			ret = graphql.Null
 7997		}
 7998	}()
 7999	fc := &graphql.FieldContext{
 8000		Object:   "SetStatusOperation",
 8001		Field:    field,
 8002		Args:     nil,
 8003		IsMethod: true,
 8004	}
 8005
 8006	ctx = graphql.WithFieldContext(ctx, fc)
 8007	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8008		ctx = rctx // use context from middleware stack in children
 8009		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8010	})
 8011	if err != nil {
 8012		ec.Error(ctx, err)
 8013		return graphql.Null
 8014	}
 8015	if resTmp == nil {
 8016		if !graphql.HasFieldError(ctx, fc) {
 8017			ec.Errorf(ctx, "must not be null")
 8018		}
 8019		return graphql.Null
 8020	}
 8021	res := resTmp.(models.Status)
 8022	fc.Result = res
 8023	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8024}
 8025
 8026func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8027	defer func() {
 8028		if r := recover(); r != nil {
 8029			ec.Error(ctx, ec.Recover(ctx, r))
 8030			ret = graphql.Null
 8031		}
 8032	}()
 8033	fc := &graphql.FieldContext{
 8034		Object:   "SetStatusTimelineItem",
 8035		Field:    field,
 8036		Args:     nil,
 8037		IsMethod: true,
 8038	}
 8039
 8040	ctx = graphql.WithFieldContext(ctx, fc)
 8041	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8042		ctx = rctx // use context from middleware stack in children
 8043		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8044	})
 8045	if err != nil {
 8046		ec.Error(ctx, err)
 8047		return graphql.Null
 8048	}
 8049	if resTmp == nil {
 8050		if !graphql.HasFieldError(ctx, fc) {
 8051			ec.Errorf(ctx, "must not be null")
 8052		}
 8053		return graphql.Null
 8054	}
 8055	res := resTmp.(string)
 8056	fc.Result = res
 8057	return ec.marshalNString2string(ctx, field.Selections, res)
 8058}
 8059
 8060func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8061	defer func() {
 8062		if r := recover(); r != nil {
 8063			ec.Error(ctx, ec.Recover(ctx, r))
 8064			ret = graphql.Null
 8065		}
 8066	}()
 8067	fc := &graphql.FieldContext{
 8068		Object:   "SetStatusTimelineItem",
 8069		Field:    field,
 8070		Args:     nil,
 8071		IsMethod: true,
 8072	}
 8073
 8074	ctx = graphql.WithFieldContext(ctx, fc)
 8075	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8076		ctx = rctx // use context from middleware stack in children
 8077		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
 8078	})
 8079	if err != nil {
 8080		ec.Error(ctx, err)
 8081		return graphql.Null
 8082	}
 8083	if resTmp == nil {
 8084		if !graphql.HasFieldError(ctx, fc) {
 8085			ec.Errorf(ctx, "must not be null")
 8086		}
 8087		return graphql.Null
 8088	}
 8089	res := resTmp.(models.IdentityWrapper)
 8090	fc.Result = res
 8091	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8092}
 8093
 8094func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8095	defer func() {
 8096		if r := recover(); r != nil {
 8097			ec.Error(ctx, ec.Recover(ctx, r))
 8098			ret = graphql.Null
 8099		}
 8100	}()
 8101	fc := &graphql.FieldContext{
 8102		Object:   "SetStatusTimelineItem",
 8103		Field:    field,
 8104		Args:     nil,
 8105		IsMethod: true,
 8106	}
 8107
 8108	ctx = graphql.WithFieldContext(ctx, fc)
 8109	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8110		ctx = rctx // use context from middleware stack in children
 8111		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8112	})
 8113	if err != nil {
 8114		ec.Error(ctx, err)
 8115		return graphql.Null
 8116	}
 8117	if resTmp == nil {
 8118		if !graphql.HasFieldError(ctx, fc) {
 8119			ec.Errorf(ctx, "must not be null")
 8120		}
 8121		return graphql.Null
 8122	}
 8123	res := resTmp.(*time.Time)
 8124	fc.Result = res
 8125	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8126}
 8127
 8128func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8129	defer func() {
 8130		if r := recover(); r != nil {
 8131			ec.Error(ctx, ec.Recover(ctx, r))
 8132			ret = graphql.Null
 8133		}
 8134	}()
 8135	fc := &graphql.FieldContext{
 8136		Object:   "SetStatusTimelineItem",
 8137		Field:    field,
 8138		Args:     nil,
 8139		IsMethod: true,
 8140	}
 8141
 8142	ctx = graphql.WithFieldContext(ctx, fc)
 8143	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8144		ctx = rctx // use context from middleware stack in children
 8145		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8146	})
 8147	if err != nil {
 8148		ec.Error(ctx, err)
 8149		return graphql.Null
 8150	}
 8151	if resTmp == nil {
 8152		if !graphql.HasFieldError(ctx, fc) {
 8153			ec.Errorf(ctx, "must not be null")
 8154		}
 8155		return graphql.Null
 8156	}
 8157	res := resTmp.(models.Status)
 8158	fc.Result = res
 8159	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8160}
 8161
 8162func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (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:   "SetTitleOperation",
 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.resolvers.SetTitleOperation().ID(rctx, obj)
 8180	})
 8181	if err != nil {
 8182		ec.Error(ctx, err)
 8183		return graphql.Null
 8184	}
 8185	if resTmp == nil {
 8186		if !graphql.HasFieldError(ctx, fc) {
 8187			ec.Errorf(ctx, "must not be null")
 8188		}
 8189		return graphql.Null
 8190	}
 8191	res := resTmp.(string)
 8192	fc.Result = res
 8193	return ec.marshalNString2string(ctx, field.Selections, res)
 8194}
 8195
 8196func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8197	defer func() {
 8198		if r := recover(); r != nil {
 8199			ec.Error(ctx, ec.Recover(ctx, r))
 8200			ret = graphql.Null
 8201		}
 8202	}()
 8203	fc := &graphql.FieldContext{
 8204		Object:   "SetTitleOperation",
 8205		Field:    field,
 8206		Args:     nil,
 8207		IsMethod: true,
 8208	}
 8209
 8210	ctx = graphql.WithFieldContext(ctx, fc)
 8211	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8212		ctx = rctx // use context from middleware stack in children
 8213		return ec.resolvers.SetTitleOperation().Author(rctx, obj)
 8214	})
 8215	if err != nil {
 8216		ec.Error(ctx, err)
 8217		return graphql.Null
 8218	}
 8219	if resTmp == nil {
 8220		if !graphql.HasFieldError(ctx, fc) {
 8221			ec.Errorf(ctx, "must not be null")
 8222		}
 8223		return graphql.Null
 8224	}
 8225	res := resTmp.(models.IdentityWrapper)
 8226	fc.Result = res
 8227	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8228}
 8229
 8230func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8231	defer func() {
 8232		if r := recover(); r != nil {
 8233			ec.Error(ctx, ec.Recover(ctx, r))
 8234			ret = graphql.Null
 8235		}
 8236	}()
 8237	fc := &graphql.FieldContext{
 8238		Object:   "SetTitleOperation",
 8239		Field:    field,
 8240		Args:     nil,
 8241		IsMethod: true,
 8242	}
 8243
 8244	ctx = graphql.WithFieldContext(ctx, fc)
 8245	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8246		ctx = rctx // use context from middleware stack in children
 8247		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8248	})
 8249	if err != nil {
 8250		ec.Error(ctx, err)
 8251		return graphql.Null
 8252	}
 8253	if resTmp == nil {
 8254		if !graphql.HasFieldError(ctx, fc) {
 8255			ec.Errorf(ctx, "must not be null")
 8256		}
 8257		return graphql.Null
 8258	}
 8259	res := resTmp.(*time.Time)
 8260	fc.Result = res
 8261	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8262}
 8263
 8264func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8265	defer func() {
 8266		if r := recover(); r != nil {
 8267			ec.Error(ctx, ec.Recover(ctx, r))
 8268			ret = graphql.Null
 8269		}
 8270	}()
 8271	fc := &graphql.FieldContext{
 8272		Object:   "SetTitleOperation",
 8273		Field:    field,
 8274		Args:     nil,
 8275		IsMethod: false,
 8276	}
 8277
 8278	ctx = graphql.WithFieldContext(ctx, fc)
 8279	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8280		ctx = rctx // use context from middleware stack in children
 8281		return obj.Title, nil
 8282	})
 8283	if err != nil {
 8284		ec.Error(ctx, err)
 8285		return graphql.Null
 8286	}
 8287	if resTmp == nil {
 8288		if !graphql.HasFieldError(ctx, fc) {
 8289			ec.Errorf(ctx, "must not be null")
 8290		}
 8291		return graphql.Null
 8292	}
 8293	res := resTmp.(string)
 8294	fc.Result = res
 8295	return ec.marshalNString2string(ctx, field.Selections, res)
 8296}
 8297
 8298func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8299	defer func() {
 8300		if r := recover(); r != nil {
 8301			ec.Error(ctx, ec.Recover(ctx, r))
 8302			ret = graphql.Null
 8303		}
 8304	}()
 8305	fc := &graphql.FieldContext{
 8306		Object:   "SetTitleOperation",
 8307		Field:    field,
 8308		Args:     nil,
 8309		IsMethod: false,
 8310	}
 8311
 8312	ctx = graphql.WithFieldContext(ctx, fc)
 8313	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8314		ctx = rctx // use context from middleware stack in children
 8315		return obj.Was, nil
 8316	})
 8317	if err != nil {
 8318		ec.Error(ctx, err)
 8319		return graphql.Null
 8320	}
 8321	if resTmp == nil {
 8322		if !graphql.HasFieldError(ctx, fc) {
 8323			ec.Errorf(ctx, "must not be null")
 8324		}
 8325		return graphql.Null
 8326	}
 8327	res := resTmp.(string)
 8328	fc.Result = res
 8329	return ec.marshalNString2string(ctx, field.Selections, res)
 8330}
 8331
 8332func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8333	defer func() {
 8334		if r := recover(); r != nil {
 8335			ec.Error(ctx, ec.Recover(ctx, r))
 8336			ret = graphql.Null
 8337		}
 8338	}()
 8339	fc := &graphql.FieldContext{
 8340		Object:   "SetTitlePayload",
 8341		Field:    field,
 8342		Args:     nil,
 8343		IsMethod: false,
 8344	}
 8345
 8346	ctx = graphql.WithFieldContext(ctx, fc)
 8347	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8348		ctx = rctx // use context from middleware stack in children
 8349		return obj.ClientMutationID, nil
 8350	})
 8351	if err != nil {
 8352		ec.Error(ctx, err)
 8353		return graphql.Null
 8354	}
 8355	if resTmp == nil {
 8356		return graphql.Null
 8357	}
 8358	res := resTmp.(*string)
 8359	fc.Result = res
 8360	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8361}
 8362
 8363func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8364	defer func() {
 8365		if r := recover(); r != nil {
 8366			ec.Error(ctx, ec.Recover(ctx, r))
 8367			ret = graphql.Null
 8368		}
 8369	}()
 8370	fc := &graphql.FieldContext{
 8371		Object:   "SetTitlePayload",
 8372		Field:    field,
 8373		Args:     nil,
 8374		IsMethod: false,
 8375	}
 8376
 8377	ctx = graphql.WithFieldContext(ctx, fc)
 8378	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8379		ctx = rctx // use context from middleware stack in children
 8380		return obj.Bug, nil
 8381	})
 8382	if err != nil {
 8383		ec.Error(ctx, err)
 8384		return graphql.Null
 8385	}
 8386	if resTmp == nil {
 8387		if !graphql.HasFieldError(ctx, fc) {
 8388			ec.Errorf(ctx, "must not be null")
 8389		}
 8390		return graphql.Null
 8391	}
 8392	res := resTmp.(models.BugWrapper)
 8393	fc.Result = res
 8394	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 8395}
 8396
 8397func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8398	defer func() {
 8399		if r := recover(); r != nil {
 8400			ec.Error(ctx, ec.Recover(ctx, r))
 8401			ret = graphql.Null
 8402		}
 8403	}()
 8404	fc := &graphql.FieldContext{
 8405		Object:   "SetTitlePayload",
 8406		Field:    field,
 8407		Args:     nil,
 8408		IsMethod: false,
 8409	}
 8410
 8411	ctx = graphql.WithFieldContext(ctx, fc)
 8412	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8413		ctx = rctx // use context from middleware stack in children
 8414		return obj.Operation, nil
 8415	})
 8416	if err != nil {
 8417		ec.Error(ctx, err)
 8418		return graphql.Null
 8419	}
 8420	if resTmp == nil {
 8421		if !graphql.HasFieldError(ctx, fc) {
 8422			ec.Errorf(ctx, "must not be null")
 8423		}
 8424		return graphql.Null
 8425	}
 8426	res := resTmp.(*bug.SetTitleOperation)
 8427	fc.Result = res
 8428	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8429}
 8430
 8431func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8432	defer func() {
 8433		if r := recover(); r != nil {
 8434			ec.Error(ctx, ec.Recover(ctx, r))
 8435			ret = graphql.Null
 8436		}
 8437	}()
 8438	fc := &graphql.FieldContext{
 8439		Object:   "SetTitleTimelineItem",
 8440		Field:    field,
 8441		Args:     nil,
 8442		IsMethod: true,
 8443	}
 8444
 8445	ctx = graphql.WithFieldContext(ctx, fc)
 8446	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8447		ctx = rctx // use context from middleware stack in children
 8448		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8449	})
 8450	if err != nil {
 8451		ec.Error(ctx, err)
 8452		return graphql.Null
 8453	}
 8454	if resTmp == nil {
 8455		if !graphql.HasFieldError(ctx, fc) {
 8456			ec.Errorf(ctx, "must not be null")
 8457		}
 8458		return graphql.Null
 8459	}
 8460	res := resTmp.(string)
 8461	fc.Result = res
 8462	return ec.marshalNString2string(ctx, field.Selections, res)
 8463}
 8464
 8465func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8466	defer func() {
 8467		if r := recover(); r != nil {
 8468			ec.Error(ctx, ec.Recover(ctx, r))
 8469			ret = graphql.Null
 8470		}
 8471	}()
 8472	fc := &graphql.FieldContext{
 8473		Object:   "SetTitleTimelineItem",
 8474		Field:    field,
 8475		Args:     nil,
 8476		IsMethod: true,
 8477	}
 8478
 8479	ctx = graphql.WithFieldContext(ctx, fc)
 8480	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8481		ctx = rctx // use context from middleware stack in children
 8482		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
 8483	})
 8484	if err != nil {
 8485		ec.Error(ctx, err)
 8486		return graphql.Null
 8487	}
 8488	if resTmp == nil {
 8489		if !graphql.HasFieldError(ctx, fc) {
 8490			ec.Errorf(ctx, "must not be null")
 8491		}
 8492		return graphql.Null
 8493	}
 8494	res := resTmp.(models.IdentityWrapper)
 8495	fc.Result = res
 8496	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8497}
 8498
 8499func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8500	defer func() {
 8501		if r := recover(); r != nil {
 8502			ec.Error(ctx, ec.Recover(ctx, r))
 8503			ret = graphql.Null
 8504		}
 8505	}()
 8506	fc := &graphql.FieldContext{
 8507		Object:   "SetTitleTimelineItem",
 8508		Field:    field,
 8509		Args:     nil,
 8510		IsMethod: true,
 8511	}
 8512
 8513	ctx = graphql.WithFieldContext(ctx, fc)
 8514	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8515		ctx = rctx // use context from middleware stack in children
 8516		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8517	})
 8518	if err != nil {
 8519		ec.Error(ctx, err)
 8520		return graphql.Null
 8521	}
 8522	if resTmp == nil {
 8523		if !graphql.HasFieldError(ctx, fc) {
 8524			ec.Errorf(ctx, "must not be null")
 8525		}
 8526		return graphql.Null
 8527	}
 8528	res := resTmp.(*time.Time)
 8529	fc.Result = res
 8530	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8531}
 8532
 8533func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8534	defer func() {
 8535		if r := recover(); r != nil {
 8536			ec.Error(ctx, ec.Recover(ctx, r))
 8537			ret = graphql.Null
 8538		}
 8539	}()
 8540	fc := &graphql.FieldContext{
 8541		Object:   "SetTitleTimelineItem",
 8542		Field:    field,
 8543		Args:     nil,
 8544		IsMethod: false,
 8545	}
 8546
 8547	ctx = graphql.WithFieldContext(ctx, fc)
 8548	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8549		ctx = rctx // use context from middleware stack in children
 8550		return obj.Title, nil
 8551	})
 8552	if err != nil {
 8553		ec.Error(ctx, err)
 8554		return graphql.Null
 8555	}
 8556	if resTmp == nil {
 8557		if !graphql.HasFieldError(ctx, fc) {
 8558			ec.Errorf(ctx, "must not be null")
 8559		}
 8560		return graphql.Null
 8561	}
 8562	res := resTmp.(string)
 8563	fc.Result = res
 8564	return ec.marshalNString2string(ctx, field.Selections, res)
 8565}
 8566
 8567func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8568	defer func() {
 8569		if r := recover(); r != nil {
 8570			ec.Error(ctx, ec.Recover(ctx, r))
 8571			ret = graphql.Null
 8572		}
 8573	}()
 8574	fc := &graphql.FieldContext{
 8575		Object:   "SetTitleTimelineItem",
 8576		Field:    field,
 8577		Args:     nil,
 8578		IsMethod: false,
 8579	}
 8580
 8581	ctx = graphql.WithFieldContext(ctx, fc)
 8582	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8583		ctx = rctx // use context from middleware stack in children
 8584		return obj.Was, nil
 8585	})
 8586	if err != nil {
 8587		ec.Error(ctx, err)
 8588		return graphql.Null
 8589	}
 8590	if resTmp == nil {
 8591		if !graphql.HasFieldError(ctx, fc) {
 8592			ec.Errorf(ctx, "must not be null")
 8593		}
 8594		return graphql.Null
 8595	}
 8596	res := resTmp.(string)
 8597	fc.Result = res
 8598	return ec.marshalNString2string(ctx, field.Selections, res)
 8599}
 8600
 8601func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8602	defer func() {
 8603		if r := recover(); r != nil {
 8604			ec.Error(ctx, ec.Recover(ctx, r))
 8605			ret = graphql.Null
 8606		}
 8607	}()
 8608	fc := &graphql.FieldContext{
 8609		Object:   "TimelineItemConnection",
 8610		Field:    field,
 8611		Args:     nil,
 8612		IsMethod: false,
 8613	}
 8614
 8615	ctx = graphql.WithFieldContext(ctx, fc)
 8616	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8617		ctx = rctx // use context from middleware stack in children
 8618		return obj.Edges, nil
 8619	})
 8620	if err != nil {
 8621		ec.Error(ctx, err)
 8622		return graphql.Null
 8623	}
 8624	if resTmp == nil {
 8625		if !graphql.HasFieldError(ctx, fc) {
 8626			ec.Errorf(ctx, "must not be null")
 8627		}
 8628		return graphql.Null
 8629	}
 8630	res := resTmp.([]*models.TimelineItemEdge)
 8631	fc.Result = res
 8632	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 8633}
 8634
 8635func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8636	defer func() {
 8637		if r := recover(); r != nil {
 8638			ec.Error(ctx, ec.Recover(ctx, r))
 8639			ret = graphql.Null
 8640		}
 8641	}()
 8642	fc := &graphql.FieldContext{
 8643		Object:   "TimelineItemConnection",
 8644		Field:    field,
 8645		Args:     nil,
 8646		IsMethod: false,
 8647	}
 8648
 8649	ctx = graphql.WithFieldContext(ctx, fc)
 8650	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8651		ctx = rctx // use context from middleware stack in children
 8652		return obj.Nodes, nil
 8653	})
 8654	if err != nil {
 8655		ec.Error(ctx, err)
 8656		return graphql.Null
 8657	}
 8658	if resTmp == nil {
 8659		if !graphql.HasFieldError(ctx, fc) {
 8660			ec.Errorf(ctx, "must not be null")
 8661		}
 8662		return graphql.Null
 8663	}
 8664	res := resTmp.([]bug.TimelineItem)
 8665	fc.Result = res
 8666	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 8667}
 8668
 8669func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8670	defer func() {
 8671		if r := recover(); r != nil {
 8672			ec.Error(ctx, ec.Recover(ctx, r))
 8673			ret = graphql.Null
 8674		}
 8675	}()
 8676	fc := &graphql.FieldContext{
 8677		Object:   "TimelineItemConnection",
 8678		Field:    field,
 8679		Args:     nil,
 8680		IsMethod: false,
 8681	}
 8682
 8683	ctx = graphql.WithFieldContext(ctx, fc)
 8684	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8685		ctx = rctx // use context from middleware stack in children
 8686		return obj.PageInfo, nil
 8687	})
 8688	if err != nil {
 8689		ec.Error(ctx, err)
 8690		return graphql.Null
 8691	}
 8692	if resTmp == nil {
 8693		if !graphql.HasFieldError(ctx, fc) {
 8694			ec.Errorf(ctx, "must not be null")
 8695		}
 8696		return graphql.Null
 8697	}
 8698	res := resTmp.(*models.PageInfo)
 8699	fc.Result = res
 8700	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 8701}
 8702
 8703func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8704	defer func() {
 8705		if r := recover(); r != nil {
 8706			ec.Error(ctx, ec.Recover(ctx, r))
 8707			ret = graphql.Null
 8708		}
 8709	}()
 8710	fc := &graphql.FieldContext{
 8711		Object:   "TimelineItemConnection",
 8712		Field:    field,
 8713		Args:     nil,
 8714		IsMethod: false,
 8715	}
 8716
 8717	ctx = graphql.WithFieldContext(ctx, fc)
 8718	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8719		ctx = rctx // use context from middleware stack in children
 8720		return obj.TotalCount, nil
 8721	})
 8722	if err != nil {
 8723		ec.Error(ctx, err)
 8724		return graphql.Null
 8725	}
 8726	if resTmp == nil {
 8727		if !graphql.HasFieldError(ctx, fc) {
 8728			ec.Errorf(ctx, "must not be null")
 8729		}
 8730		return graphql.Null
 8731	}
 8732	res := resTmp.(int)
 8733	fc.Result = res
 8734	return ec.marshalNInt2int(ctx, field.Selections, res)
 8735}
 8736
 8737func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8738	defer func() {
 8739		if r := recover(); r != nil {
 8740			ec.Error(ctx, ec.Recover(ctx, r))
 8741			ret = graphql.Null
 8742		}
 8743	}()
 8744	fc := &graphql.FieldContext{
 8745		Object:   "TimelineItemEdge",
 8746		Field:    field,
 8747		Args:     nil,
 8748		IsMethod: false,
 8749	}
 8750
 8751	ctx = graphql.WithFieldContext(ctx, fc)
 8752	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8753		ctx = rctx // use context from middleware stack in children
 8754		return obj.Cursor, nil
 8755	})
 8756	if err != nil {
 8757		ec.Error(ctx, err)
 8758		return graphql.Null
 8759	}
 8760	if resTmp == nil {
 8761		if !graphql.HasFieldError(ctx, fc) {
 8762			ec.Errorf(ctx, "must not be null")
 8763		}
 8764		return graphql.Null
 8765	}
 8766	res := resTmp.(string)
 8767	fc.Result = res
 8768	return ec.marshalNString2string(ctx, field.Selections, res)
 8769}
 8770
 8771func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8772	defer func() {
 8773		if r := recover(); r != nil {
 8774			ec.Error(ctx, ec.Recover(ctx, r))
 8775			ret = graphql.Null
 8776		}
 8777	}()
 8778	fc := &graphql.FieldContext{
 8779		Object:   "TimelineItemEdge",
 8780		Field:    field,
 8781		Args:     nil,
 8782		IsMethod: false,
 8783	}
 8784
 8785	ctx = graphql.WithFieldContext(ctx, fc)
 8786	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8787		ctx = rctx // use context from middleware stack in children
 8788		return obj.Node, nil
 8789	})
 8790	if err != nil {
 8791		ec.Error(ctx, err)
 8792		return graphql.Null
 8793	}
 8794	if resTmp == nil {
 8795		if !graphql.HasFieldError(ctx, fc) {
 8796			ec.Errorf(ctx, "must not be null")
 8797		}
 8798		return graphql.Null
 8799	}
 8800	res := resTmp.(bug.TimelineItem)
 8801	fc.Result = res
 8802	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 8803}
 8804
 8805func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8806	defer func() {
 8807		if r := recover(); r != nil {
 8808			ec.Error(ctx, ec.Recover(ctx, r))
 8809			ret = graphql.Null
 8810		}
 8811	}()
 8812	fc := &graphql.FieldContext{
 8813		Object:   "__Directive",
 8814		Field:    field,
 8815		Args:     nil,
 8816		IsMethod: false,
 8817	}
 8818
 8819	ctx = graphql.WithFieldContext(ctx, fc)
 8820	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8821		ctx = rctx // use context from middleware stack in children
 8822		return obj.Name, nil
 8823	})
 8824	if err != nil {
 8825		ec.Error(ctx, err)
 8826		return graphql.Null
 8827	}
 8828	if resTmp == nil {
 8829		if !graphql.HasFieldError(ctx, fc) {
 8830			ec.Errorf(ctx, "must not be null")
 8831		}
 8832		return graphql.Null
 8833	}
 8834	res := resTmp.(string)
 8835	fc.Result = res
 8836	return ec.marshalNString2string(ctx, field.Selections, res)
 8837}
 8838
 8839func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8840	defer func() {
 8841		if r := recover(); r != nil {
 8842			ec.Error(ctx, ec.Recover(ctx, r))
 8843			ret = graphql.Null
 8844		}
 8845	}()
 8846	fc := &graphql.FieldContext{
 8847		Object:   "__Directive",
 8848		Field:    field,
 8849		Args:     nil,
 8850		IsMethod: false,
 8851	}
 8852
 8853	ctx = graphql.WithFieldContext(ctx, fc)
 8854	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8855		ctx = rctx // use context from middleware stack in children
 8856		return obj.Description, nil
 8857	})
 8858	if err != nil {
 8859		ec.Error(ctx, err)
 8860		return graphql.Null
 8861	}
 8862	if resTmp == nil {
 8863		return graphql.Null
 8864	}
 8865	res := resTmp.(string)
 8866	fc.Result = res
 8867	return ec.marshalOString2string(ctx, field.Selections, res)
 8868}
 8869
 8870func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8871	defer func() {
 8872		if r := recover(); r != nil {
 8873			ec.Error(ctx, ec.Recover(ctx, r))
 8874			ret = graphql.Null
 8875		}
 8876	}()
 8877	fc := &graphql.FieldContext{
 8878		Object:   "__Directive",
 8879		Field:    field,
 8880		Args:     nil,
 8881		IsMethod: false,
 8882	}
 8883
 8884	ctx = graphql.WithFieldContext(ctx, fc)
 8885	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8886		ctx = rctx // use context from middleware stack in children
 8887		return obj.Locations, nil
 8888	})
 8889	if err != nil {
 8890		ec.Error(ctx, err)
 8891		return graphql.Null
 8892	}
 8893	if resTmp == nil {
 8894		if !graphql.HasFieldError(ctx, fc) {
 8895			ec.Errorf(ctx, "must not be null")
 8896		}
 8897		return graphql.Null
 8898	}
 8899	res := resTmp.([]string)
 8900	fc.Result = res
 8901	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 8902}
 8903
 8904func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8905	defer func() {
 8906		if r := recover(); r != nil {
 8907			ec.Error(ctx, ec.Recover(ctx, r))
 8908			ret = graphql.Null
 8909		}
 8910	}()
 8911	fc := &graphql.FieldContext{
 8912		Object:   "__Directive",
 8913		Field:    field,
 8914		Args:     nil,
 8915		IsMethod: false,
 8916	}
 8917
 8918	ctx = graphql.WithFieldContext(ctx, fc)
 8919	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8920		ctx = rctx // use context from middleware stack in children
 8921		return obj.Args, nil
 8922	})
 8923	if err != nil {
 8924		ec.Error(ctx, err)
 8925		return graphql.Null
 8926	}
 8927	if resTmp == nil {
 8928		if !graphql.HasFieldError(ctx, fc) {
 8929			ec.Errorf(ctx, "must not be null")
 8930		}
 8931		return graphql.Null
 8932	}
 8933	res := resTmp.([]introspection.InputValue)
 8934	fc.Result = res
 8935	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 8936}
 8937
 8938func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8939	defer func() {
 8940		if r := recover(); r != nil {
 8941			ec.Error(ctx, ec.Recover(ctx, r))
 8942			ret = graphql.Null
 8943		}
 8944	}()
 8945	fc := &graphql.FieldContext{
 8946		Object:   "__EnumValue",
 8947		Field:    field,
 8948		Args:     nil,
 8949		IsMethod: false,
 8950	}
 8951
 8952	ctx = graphql.WithFieldContext(ctx, fc)
 8953	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8954		ctx = rctx // use context from middleware stack in children
 8955		return obj.Name, nil
 8956	})
 8957	if err != nil {
 8958		ec.Error(ctx, err)
 8959		return graphql.Null
 8960	}
 8961	if resTmp == nil {
 8962		if !graphql.HasFieldError(ctx, fc) {
 8963			ec.Errorf(ctx, "must not be null")
 8964		}
 8965		return graphql.Null
 8966	}
 8967	res := resTmp.(string)
 8968	fc.Result = res
 8969	return ec.marshalNString2string(ctx, field.Selections, res)
 8970}
 8971
 8972func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8973	defer func() {
 8974		if r := recover(); r != nil {
 8975			ec.Error(ctx, ec.Recover(ctx, r))
 8976			ret = graphql.Null
 8977		}
 8978	}()
 8979	fc := &graphql.FieldContext{
 8980		Object:   "__EnumValue",
 8981		Field:    field,
 8982		Args:     nil,
 8983		IsMethod: false,
 8984	}
 8985
 8986	ctx = graphql.WithFieldContext(ctx, fc)
 8987	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8988		ctx = rctx // use context from middleware stack in children
 8989		return obj.Description, nil
 8990	})
 8991	if err != nil {
 8992		ec.Error(ctx, err)
 8993		return graphql.Null
 8994	}
 8995	if resTmp == nil {
 8996		return graphql.Null
 8997	}
 8998	res := resTmp.(string)
 8999	fc.Result = res
 9000	return ec.marshalOString2string(ctx, field.Selections, res)
 9001}
 9002
 9003func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9004	defer func() {
 9005		if r := recover(); r != nil {
 9006			ec.Error(ctx, ec.Recover(ctx, r))
 9007			ret = graphql.Null
 9008		}
 9009	}()
 9010	fc := &graphql.FieldContext{
 9011		Object:   "__EnumValue",
 9012		Field:    field,
 9013		Args:     nil,
 9014		IsMethod: true,
 9015	}
 9016
 9017	ctx = graphql.WithFieldContext(ctx, fc)
 9018	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9019		ctx = rctx // use context from middleware stack in children
 9020		return obj.IsDeprecated(), nil
 9021	})
 9022	if err != nil {
 9023		ec.Error(ctx, err)
 9024		return graphql.Null
 9025	}
 9026	if resTmp == nil {
 9027		if !graphql.HasFieldError(ctx, fc) {
 9028			ec.Errorf(ctx, "must not be null")
 9029		}
 9030		return graphql.Null
 9031	}
 9032	res := resTmp.(bool)
 9033	fc.Result = res
 9034	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9035}
 9036
 9037func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9038	defer func() {
 9039		if r := recover(); r != nil {
 9040			ec.Error(ctx, ec.Recover(ctx, r))
 9041			ret = graphql.Null
 9042		}
 9043	}()
 9044	fc := &graphql.FieldContext{
 9045		Object:   "__EnumValue",
 9046		Field:    field,
 9047		Args:     nil,
 9048		IsMethod: true,
 9049	}
 9050
 9051	ctx = graphql.WithFieldContext(ctx, fc)
 9052	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9053		ctx = rctx // use context from middleware stack in children
 9054		return obj.DeprecationReason(), nil
 9055	})
 9056	if err != nil {
 9057		ec.Error(ctx, err)
 9058		return graphql.Null
 9059	}
 9060	if resTmp == nil {
 9061		return graphql.Null
 9062	}
 9063	res := resTmp.(*string)
 9064	fc.Result = res
 9065	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9066}
 9067
 9068func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9069	defer func() {
 9070		if r := recover(); r != nil {
 9071			ec.Error(ctx, ec.Recover(ctx, r))
 9072			ret = graphql.Null
 9073		}
 9074	}()
 9075	fc := &graphql.FieldContext{
 9076		Object:   "__Field",
 9077		Field:    field,
 9078		Args:     nil,
 9079		IsMethod: false,
 9080	}
 9081
 9082	ctx = graphql.WithFieldContext(ctx, fc)
 9083	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9084		ctx = rctx // use context from middleware stack in children
 9085		return obj.Name, nil
 9086	})
 9087	if err != nil {
 9088		ec.Error(ctx, err)
 9089		return graphql.Null
 9090	}
 9091	if resTmp == nil {
 9092		if !graphql.HasFieldError(ctx, fc) {
 9093			ec.Errorf(ctx, "must not be null")
 9094		}
 9095		return graphql.Null
 9096	}
 9097	res := resTmp.(string)
 9098	fc.Result = res
 9099	return ec.marshalNString2string(ctx, field.Selections, res)
 9100}
 9101
 9102func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9103	defer func() {
 9104		if r := recover(); r != nil {
 9105			ec.Error(ctx, ec.Recover(ctx, r))
 9106			ret = graphql.Null
 9107		}
 9108	}()
 9109	fc := &graphql.FieldContext{
 9110		Object:   "__Field",
 9111		Field:    field,
 9112		Args:     nil,
 9113		IsMethod: false,
 9114	}
 9115
 9116	ctx = graphql.WithFieldContext(ctx, fc)
 9117	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9118		ctx = rctx // use context from middleware stack in children
 9119		return obj.Description, nil
 9120	})
 9121	if err != nil {
 9122		ec.Error(ctx, err)
 9123		return graphql.Null
 9124	}
 9125	if resTmp == nil {
 9126		return graphql.Null
 9127	}
 9128	res := resTmp.(string)
 9129	fc.Result = res
 9130	return ec.marshalOString2string(ctx, field.Selections, res)
 9131}
 9132
 9133func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9134	defer func() {
 9135		if r := recover(); r != nil {
 9136			ec.Error(ctx, ec.Recover(ctx, r))
 9137			ret = graphql.Null
 9138		}
 9139	}()
 9140	fc := &graphql.FieldContext{
 9141		Object:   "__Field",
 9142		Field:    field,
 9143		Args:     nil,
 9144		IsMethod: false,
 9145	}
 9146
 9147	ctx = graphql.WithFieldContext(ctx, fc)
 9148	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9149		ctx = rctx // use context from middleware stack in children
 9150		return obj.Args, nil
 9151	})
 9152	if err != nil {
 9153		ec.Error(ctx, err)
 9154		return graphql.Null
 9155	}
 9156	if resTmp == nil {
 9157		if !graphql.HasFieldError(ctx, fc) {
 9158			ec.Errorf(ctx, "must not be null")
 9159		}
 9160		return graphql.Null
 9161	}
 9162	res := resTmp.([]introspection.InputValue)
 9163	fc.Result = res
 9164	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9165}
 9166
 9167func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9168	defer func() {
 9169		if r := recover(); r != nil {
 9170			ec.Error(ctx, ec.Recover(ctx, r))
 9171			ret = graphql.Null
 9172		}
 9173	}()
 9174	fc := &graphql.FieldContext{
 9175		Object:   "__Field",
 9176		Field:    field,
 9177		Args:     nil,
 9178		IsMethod: false,
 9179	}
 9180
 9181	ctx = graphql.WithFieldContext(ctx, fc)
 9182	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9183		ctx = rctx // use context from middleware stack in children
 9184		return obj.Type, nil
 9185	})
 9186	if err != nil {
 9187		ec.Error(ctx, err)
 9188		return graphql.Null
 9189	}
 9190	if resTmp == nil {
 9191		if !graphql.HasFieldError(ctx, fc) {
 9192			ec.Errorf(ctx, "must not be null")
 9193		}
 9194		return graphql.Null
 9195	}
 9196	res := resTmp.(*introspection.Type)
 9197	fc.Result = res
 9198	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9199}
 9200
 9201func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9202	defer func() {
 9203		if r := recover(); r != nil {
 9204			ec.Error(ctx, ec.Recover(ctx, r))
 9205			ret = graphql.Null
 9206		}
 9207	}()
 9208	fc := &graphql.FieldContext{
 9209		Object:   "__Field",
 9210		Field:    field,
 9211		Args:     nil,
 9212		IsMethod: true,
 9213	}
 9214
 9215	ctx = graphql.WithFieldContext(ctx, fc)
 9216	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9217		ctx = rctx // use context from middleware stack in children
 9218		return obj.IsDeprecated(), nil
 9219	})
 9220	if err != nil {
 9221		ec.Error(ctx, err)
 9222		return graphql.Null
 9223	}
 9224	if resTmp == nil {
 9225		if !graphql.HasFieldError(ctx, fc) {
 9226			ec.Errorf(ctx, "must not be null")
 9227		}
 9228		return graphql.Null
 9229	}
 9230	res := resTmp.(bool)
 9231	fc.Result = res
 9232	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9233}
 9234
 9235func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9236	defer func() {
 9237		if r := recover(); r != nil {
 9238			ec.Error(ctx, ec.Recover(ctx, r))
 9239			ret = graphql.Null
 9240		}
 9241	}()
 9242	fc := &graphql.FieldContext{
 9243		Object:   "__Field",
 9244		Field:    field,
 9245		Args:     nil,
 9246		IsMethod: true,
 9247	}
 9248
 9249	ctx = graphql.WithFieldContext(ctx, fc)
 9250	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9251		ctx = rctx // use context from middleware stack in children
 9252		return obj.DeprecationReason(), nil
 9253	})
 9254	if err != nil {
 9255		ec.Error(ctx, err)
 9256		return graphql.Null
 9257	}
 9258	if resTmp == nil {
 9259		return graphql.Null
 9260	}
 9261	res := resTmp.(*string)
 9262	fc.Result = res
 9263	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9264}
 9265
 9266func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9267	defer func() {
 9268		if r := recover(); r != nil {
 9269			ec.Error(ctx, ec.Recover(ctx, r))
 9270			ret = graphql.Null
 9271		}
 9272	}()
 9273	fc := &graphql.FieldContext{
 9274		Object:   "__InputValue",
 9275		Field:    field,
 9276		Args:     nil,
 9277		IsMethod: false,
 9278	}
 9279
 9280	ctx = graphql.WithFieldContext(ctx, fc)
 9281	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9282		ctx = rctx // use context from middleware stack in children
 9283		return obj.Name, nil
 9284	})
 9285	if err != nil {
 9286		ec.Error(ctx, err)
 9287		return graphql.Null
 9288	}
 9289	if resTmp == nil {
 9290		if !graphql.HasFieldError(ctx, fc) {
 9291			ec.Errorf(ctx, "must not be null")
 9292		}
 9293		return graphql.Null
 9294	}
 9295	res := resTmp.(string)
 9296	fc.Result = res
 9297	return ec.marshalNString2string(ctx, field.Selections, res)
 9298}
 9299
 9300func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9301	defer func() {
 9302		if r := recover(); r != nil {
 9303			ec.Error(ctx, ec.Recover(ctx, r))
 9304			ret = graphql.Null
 9305		}
 9306	}()
 9307	fc := &graphql.FieldContext{
 9308		Object:   "__InputValue",
 9309		Field:    field,
 9310		Args:     nil,
 9311		IsMethod: false,
 9312	}
 9313
 9314	ctx = graphql.WithFieldContext(ctx, fc)
 9315	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9316		ctx = rctx // use context from middleware stack in children
 9317		return obj.Description, nil
 9318	})
 9319	if err != nil {
 9320		ec.Error(ctx, err)
 9321		return graphql.Null
 9322	}
 9323	if resTmp == nil {
 9324		return graphql.Null
 9325	}
 9326	res := resTmp.(string)
 9327	fc.Result = res
 9328	return ec.marshalOString2string(ctx, field.Selections, res)
 9329}
 9330
 9331func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9332	defer func() {
 9333		if r := recover(); r != nil {
 9334			ec.Error(ctx, ec.Recover(ctx, r))
 9335			ret = graphql.Null
 9336		}
 9337	}()
 9338	fc := &graphql.FieldContext{
 9339		Object:   "__InputValue",
 9340		Field:    field,
 9341		Args:     nil,
 9342		IsMethod: false,
 9343	}
 9344
 9345	ctx = graphql.WithFieldContext(ctx, fc)
 9346	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9347		ctx = rctx // use context from middleware stack in children
 9348		return obj.Type, nil
 9349	})
 9350	if err != nil {
 9351		ec.Error(ctx, err)
 9352		return graphql.Null
 9353	}
 9354	if resTmp == nil {
 9355		if !graphql.HasFieldError(ctx, fc) {
 9356			ec.Errorf(ctx, "must not be null")
 9357		}
 9358		return graphql.Null
 9359	}
 9360	res := resTmp.(*introspection.Type)
 9361	fc.Result = res
 9362	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9363}
 9364
 9365func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9366	defer func() {
 9367		if r := recover(); r != nil {
 9368			ec.Error(ctx, ec.Recover(ctx, r))
 9369			ret = graphql.Null
 9370		}
 9371	}()
 9372	fc := &graphql.FieldContext{
 9373		Object:   "__InputValue",
 9374		Field:    field,
 9375		Args:     nil,
 9376		IsMethod: false,
 9377	}
 9378
 9379	ctx = graphql.WithFieldContext(ctx, fc)
 9380	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9381		ctx = rctx // use context from middleware stack in children
 9382		return obj.DefaultValue, nil
 9383	})
 9384	if err != nil {
 9385		ec.Error(ctx, err)
 9386		return graphql.Null
 9387	}
 9388	if resTmp == nil {
 9389		return graphql.Null
 9390	}
 9391	res := resTmp.(*string)
 9392	fc.Result = res
 9393	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9394}
 9395
 9396func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9397	defer func() {
 9398		if r := recover(); r != nil {
 9399			ec.Error(ctx, ec.Recover(ctx, r))
 9400			ret = graphql.Null
 9401		}
 9402	}()
 9403	fc := &graphql.FieldContext{
 9404		Object:   "__Schema",
 9405		Field:    field,
 9406		Args:     nil,
 9407		IsMethod: true,
 9408	}
 9409
 9410	ctx = graphql.WithFieldContext(ctx, fc)
 9411	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9412		ctx = rctx // use context from middleware stack in children
 9413		return obj.Types(), nil
 9414	})
 9415	if err != nil {
 9416		ec.Error(ctx, err)
 9417		return graphql.Null
 9418	}
 9419	if resTmp == nil {
 9420		if !graphql.HasFieldError(ctx, fc) {
 9421			ec.Errorf(ctx, "must not be null")
 9422		}
 9423		return graphql.Null
 9424	}
 9425	res := resTmp.([]introspection.Type)
 9426	fc.Result = res
 9427	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9428}
 9429
 9430func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9431	defer func() {
 9432		if r := recover(); r != nil {
 9433			ec.Error(ctx, ec.Recover(ctx, r))
 9434			ret = graphql.Null
 9435		}
 9436	}()
 9437	fc := &graphql.FieldContext{
 9438		Object:   "__Schema",
 9439		Field:    field,
 9440		Args:     nil,
 9441		IsMethod: true,
 9442	}
 9443
 9444	ctx = graphql.WithFieldContext(ctx, fc)
 9445	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9446		ctx = rctx // use context from middleware stack in children
 9447		return obj.QueryType(), nil
 9448	})
 9449	if err != nil {
 9450		ec.Error(ctx, err)
 9451		return graphql.Null
 9452	}
 9453	if resTmp == nil {
 9454		if !graphql.HasFieldError(ctx, fc) {
 9455			ec.Errorf(ctx, "must not be null")
 9456		}
 9457		return graphql.Null
 9458	}
 9459	res := resTmp.(*introspection.Type)
 9460	fc.Result = res
 9461	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9462}
 9463
 9464func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9465	defer func() {
 9466		if r := recover(); r != nil {
 9467			ec.Error(ctx, ec.Recover(ctx, r))
 9468			ret = graphql.Null
 9469		}
 9470	}()
 9471	fc := &graphql.FieldContext{
 9472		Object:   "__Schema",
 9473		Field:    field,
 9474		Args:     nil,
 9475		IsMethod: true,
 9476	}
 9477
 9478	ctx = graphql.WithFieldContext(ctx, fc)
 9479	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9480		ctx = rctx // use context from middleware stack in children
 9481		return obj.MutationType(), nil
 9482	})
 9483	if err != nil {
 9484		ec.Error(ctx, err)
 9485		return graphql.Null
 9486	}
 9487	if resTmp == nil {
 9488		return graphql.Null
 9489	}
 9490	res := resTmp.(*introspection.Type)
 9491	fc.Result = res
 9492	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9493}
 9494
 9495func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9496	defer func() {
 9497		if r := recover(); r != nil {
 9498			ec.Error(ctx, ec.Recover(ctx, r))
 9499			ret = graphql.Null
 9500		}
 9501	}()
 9502	fc := &graphql.FieldContext{
 9503		Object:   "__Schema",
 9504		Field:    field,
 9505		Args:     nil,
 9506		IsMethod: true,
 9507	}
 9508
 9509	ctx = graphql.WithFieldContext(ctx, fc)
 9510	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9511		ctx = rctx // use context from middleware stack in children
 9512		return obj.SubscriptionType(), nil
 9513	})
 9514	if err != nil {
 9515		ec.Error(ctx, err)
 9516		return graphql.Null
 9517	}
 9518	if resTmp == nil {
 9519		return graphql.Null
 9520	}
 9521	res := resTmp.(*introspection.Type)
 9522	fc.Result = res
 9523	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9524}
 9525
 9526func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9527	defer func() {
 9528		if r := recover(); r != nil {
 9529			ec.Error(ctx, ec.Recover(ctx, r))
 9530			ret = graphql.Null
 9531		}
 9532	}()
 9533	fc := &graphql.FieldContext{
 9534		Object:   "__Schema",
 9535		Field:    field,
 9536		Args:     nil,
 9537		IsMethod: true,
 9538	}
 9539
 9540	ctx = graphql.WithFieldContext(ctx, fc)
 9541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9542		ctx = rctx // use context from middleware stack in children
 9543		return obj.Directives(), nil
 9544	})
 9545	if err != nil {
 9546		ec.Error(ctx, err)
 9547		return graphql.Null
 9548	}
 9549	if resTmp == nil {
 9550		if !graphql.HasFieldError(ctx, fc) {
 9551			ec.Errorf(ctx, "must not be null")
 9552		}
 9553		return graphql.Null
 9554	}
 9555	res := resTmp.([]introspection.Directive)
 9556	fc.Result = res
 9557	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
 9558}
 9559
 9560func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9561	defer func() {
 9562		if r := recover(); r != nil {
 9563			ec.Error(ctx, ec.Recover(ctx, r))
 9564			ret = graphql.Null
 9565		}
 9566	}()
 9567	fc := &graphql.FieldContext{
 9568		Object:   "__Type",
 9569		Field:    field,
 9570		Args:     nil,
 9571		IsMethod: true,
 9572	}
 9573
 9574	ctx = graphql.WithFieldContext(ctx, fc)
 9575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9576		ctx = rctx // use context from middleware stack in children
 9577		return obj.Kind(), nil
 9578	})
 9579	if err != nil {
 9580		ec.Error(ctx, err)
 9581		return graphql.Null
 9582	}
 9583	if resTmp == nil {
 9584		if !graphql.HasFieldError(ctx, fc) {
 9585			ec.Errorf(ctx, "must not be null")
 9586		}
 9587		return graphql.Null
 9588	}
 9589	res := resTmp.(string)
 9590	fc.Result = res
 9591	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 9592}
 9593
 9594func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9595	defer func() {
 9596		if r := recover(); r != nil {
 9597			ec.Error(ctx, ec.Recover(ctx, r))
 9598			ret = graphql.Null
 9599		}
 9600	}()
 9601	fc := &graphql.FieldContext{
 9602		Object:   "__Type",
 9603		Field:    field,
 9604		Args:     nil,
 9605		IsMethod: true,
 9606	}
 9607
 9608	ctx = graphql.WithFieldContext(ctx, fc)
 9609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9610		ctx = rctx // use context from middleware stack in children
 9611		return obj.Name(), nil
 9612	})
 9613	if err != nil {
 9614		ec.Error(ctx, err)
 9615		return graphql.Null
 9616	}
 9617	if resTmp == nil {
 9618		return graphql.Null
 9619	}
 9620	res := resTmp.(*string)
 9621	fc.Result = res
 9622	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9623}
 9624
 9625func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9626	defer func() {
 9627		if r := recover(); r != nil {
 9628			ec.Error(ctx, ec.Recover(ctx, r))
 9629			ret = graphql.Null
 9630		}
 9631	}()
 9632	fc := &graphql.FieldContext{
 9633		Object:   "__Type",
 9634		Field:    field,
 9635		Args:     nil,
 9636		IsMethod: true,
 9637	}
 9638
 9639	ctx = graphql.WithFieldContext(ctx, fc)
 9640	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9641		ctx = rctx // use context from middleware stack in children
 9642		return obj.Description(), nil
 9643	})
 9644	if err != nil {
 9645		ec.Error(ctx, err)
 9646		return graphql.Null
 9647	}
 9648	if resTmp == nil {
 9649		return graphql.Null
 9650	}
 9651	res := resTmp.(string)
 9652	fc.Result = res
 9653	return ec.marshalOString2string(ctx, field.Selections, res)
 9654}
 9655
 9656func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9657	defer func() {
 9658		if r := recover(); r != nil {
 9659			ec.Error(ctx, ec.Recover(ctx, r))
 9660			ret = graphql.Null
 9661		}
 9662	}()
 9663	fc := &graphql.FieldContext{
 9664		Object:   "__Type",
 9665		Field:    field,
 9666		Args:     nil,
 9667		IsMethod: true,
 9668	}
 9669
 9670	ctx = graphql.WithFieldContext(ctx, fc)
 9671	rawArgs := field.ArgumentMap(ec.Variables)
 9672	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 9673	if err != nil {
 9674		ec.Error(ctx, err)
 9675		return graphql.Null
 9676	}
 9677	fc.Args = args
 9678	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9679		ctx = rctx // use context from middleware stack in children
 9680		return obj.Fields(args["includeDeprecated"].(bool)), nil
 9681	})
 9682	if err != nil {
 9683		ec.Error(ctx, err)
 9684		return graphql.Null
 9685	}
 9686	if resTmp == nil {
 9687		return graphql.Null
 9688	}
 9689	res := resTmp.([]introspection.Field)
 9690	fc.Result = res
 9691	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
 9692}
 9693
 9694func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9695	defer func() {
 9696		if r := recover(); r != nil {
 9697			ec.Error(ctx, ec.Recover(ctx, r))
 9698			ret = graphql.Null
 9699		}
 9700	}()
 9701	fc := &graphql.FieldContext{
 9702		Object:   "__Type",
 9703		Field:    field,
 9704		Args:     nil,
 9705		IsMethod: true,
 9706	}
 9707
 9708	ctx = graphql.WithFieldContext(ctx, fc)
 9709	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9710		ctx = rctx // use context from middleware stack in children
 9711		return obj.Interfaces(), nil
 9712	})
 9713	if err != nil {
 9714		ec.Error(ctx, err)
 9715		return graphql.Null
 9716	}
 9717	if resTmp == nil {
 9718		return graphql.Null
 9719	}
 9720	res := resTmp.([]introspection.Type)
 9721	fc.Result = res
 9722	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9723}
 9724
 9725func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9726	defer func() {
 9727		if r := recover(); r != nil {
 9728			ec.Error(ctx, ec.Recover(ctx, r))
 9729			ret = graphql.Null
 9730		}
 9731	}()
 9732	fc := &graphql.FieldContext{
 9733		Object:   "__Type",
 9734		Field:    field,
 9735		Args:     nil,
 9736		IsMethod: true,
 9737	}
 9738
 9739	ctx = graphql.WithFieldContext(ctx, fc)
 9740	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9741		ctx = rctx // use context from middleware stack in children
 9742		return obj.PossibleTypes(), nil
 9743	})
 9744	if err != nil {
 9745		ec.Error(ctx, err)
 9746		return graphql.Null
 9747	}
 9748	if resTmp == nil {
 9749		return graphql.Null
 9750	}
 9751	res := resTmp.([]introspection.Type)
 9752	fc.Result = res
 9753	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9754}
 9755
 9756func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9757	defer func() {
 9758		if r := recover(); r != nil {
 9759			ec.Error(ctx, ec.Recover(ctx, r))
 9760			ret = graphql.Null
 9761		}
 9762	}()
 9763	fc := &graphql.FieldContext{
 9764		Object:   "__Type",
 9765		Field:    field,
 9766		Args:     nil,
 9767		IsMethod: true,
 9768	}
 9769
 9770	ctx = graphql.WithFieldContext(ctx, fc)
 9771	rawArgs := field.ArgumentMap(ec.Variables)
 9772	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
 9773	if err != nil {
 9774		ec.Error(ctx, err)
 9775		return graphql.Null
 9776	}
 9777	fc.Args = args
 9778	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9779		ctx = rctx // use context from middleware stack in children
 9780		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
 9781	})
 9782	if err != nil {
 9783		ec.Error(ctx, err)
 9784		return graphql.Null
 9785	}
 9786	if resTmp == nil {
 9787		return graphql.Null
 9788	}
 9789	res := resTmp.([]introspection.EnumValue)
 9790	fc.Result = res
 9791	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
 9792}
 9793
 9794func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9795	defer func() {
 9796		if r := recover(); r != nil {
 9797			ec.Error(ctx, ec.Recover(ctx, r))
 9798			ret = graphql.Null
 9799		}
 9800	}()
 9801	fc := &graphql.FieldContext{
 9802		Object:   "__Type",
 9803		Field:    field,
 9804		Args:     nil,
 9805		IsMethod: true,
 9806	}
 9807
 9808	ctx = graphql.WithFieldContext(ctx, fc)
 9809	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9810		ctx = rctx // use context from middleware stack in children
 9811		return obj.InputFields(), nil
 9812	})
 9813	if err != nil {
 9814		ec.Error(ctx, err)
 9815		return graphql.Null
 9816	}
 9817	if resTmp == nil {
 9818		return graphql.Null
 9819	}
 9820	res := resTmp.([]introspection.InputValue)
 9821	fc.Result = res
 9822	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9823}
 9824
 9825func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9826	defer func() {
 9827		if r := recover(); r != nil {
 9828			ec.Error(ctx, ec.Recover(ctx, r))
 9829			ret = graphql.Null
 9830		}
 9831	}()
 9832	fc := &graphql.FieldContext{
 9833		Object:   "__Type",
 9834		Field:    field,
 9835		Args:     nil,
 9836		IsMethod: true,
 9837	}
 9838
 9839	ctx = graphql.WithFieldContext(ctx, fc)
 9840	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9841		ctx = rctx // use context from middleware stack in children
 9842		return obj.OfType(), nil
 9843	})
 9844	if err != nil {
 9845		ec.Error(ctx, err)
 9846		return graphql.Null
 9847	}
 9848	if resTmp == nil {
 9849		return graphql.Null
 9850	}
 9851	res := resTmp.(*introspection.Type)
 9852	fc.Result = res
 9853	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9854}
 9855
 9856// endregion **************************** field.gotpl *****************************
 9857
 9858// region    **************************** input.gotpl *****************************
 9859
 9860func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
 9861	var it models.AddCommentInput
 9862	var asMap = obj.(map[string]interface{})
 9863
 9864	for k, v := range asMap {
 9865		switch k {
 9866		case "clientMutationId":
 9867			var err error
 9868			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9869			if err != nil {
 9870				return it, err
 9871			}
 9872		case "repoRef":
 9873			var err error
 9874			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9875			if err != nil {
 9876				return it, err
 9877			}
 9878		case "prefix":
 9879			var err error
 9880			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9881			if err != nil {
 9882				return it, err
 9883			}
 9884		case "message":
 9885			var err error
 9886			it.Message, err = ec.unmarshalNString2string(ctx, v)
 9887			if err != nil {
 9888				return it, err
 9889			}
 9890		case "files":
 9891			var err error
 9892			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
 9893			if err != nil {
 9894				return it, err
 9895			}
 9896		}
 9897	}
 9898
 9899	return it, nil
 9900}
 9901
 9902func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
 9903	var it models.ChangeLabelInput
 9904	var asMap = obj.(map[string]interface{})
 9905
 9906	for k, v := range asMap {
 9907		switch k {
 9908		case "clientMutationId":
 9909			var err error
 9910			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9911			if err != nil {
 9912				return it, err
 9913			}
 9914		case "repoRef":
 9915			var err error
 9916			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9917			if err != nil {
 9918				return it, err
 9919			}
 9920		case "prefix":
 9921			var err error
 9922			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9923			if err != nil {
 9924				return it, err
 9925			}
 9926		case "added":
 9927			var err error
 9928			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9929			if err != nil {
 9930				return it, err
 9931			}
 9932		case "Removed":
 9933			var err error
 9934			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9935			if err != nil {
 9936				return it, err
 9937			}
 9938		}
 9939	}
 9940
 9941	return it, nil
 9942}
 9943
 9944func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
 9945	var it models.CloseBugInput
 9946	var asMap = obj.(map[string]interface{})
 9947
 9948	for k, v := range asMap {
 9949		switch k {
 9950		case "clientMutationId":
 9951			var err error
 9952			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9953			if err != nil {
 9954				return it, err
 9955			}
 9956		case "repoRef":
 9957			var err error
 9958			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9959			if err != nil {
 9960				return it, err
 9961			}
 9962		case "prefix":
 9963			var err error
 9964			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9965			if err != nil {
 9966				return it, err
 9967			}
 9968		}
 9969	}
 9970
 9971	return it, nil
 9972}
 9973
 9974func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
 9975	var it models.NewBugInput
 9976	var asMap = obj.(map[string]interface{})
 9977
 9978	for k, v := range asMap {
 9979		switch k {
 9980		case "clientMutationId":
 9981			var err error
 9982			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9983			if err != nil {
 9984				return it, err
 9985			}
 9986		case "repoRef":
 9987			var err error
 9988			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9989			if err != nil {
 9990				return it, err
 9991			}
 9992		case "title":
 9993			var err error
 9994			it.Title, err = ec.unmarshalNString2string(ctx, v)
 9995			if err != nil {
 9996				return it, err
 9997			}
 9998		case "message":
 9999			var err error
10000			it.Message, err = ec.unmarshalNString2string(ctx, v)
10001			if err != nil {
10002				return it, err
10003			}
10004		case "files":
10005			var err error
10006			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10007			if err != nil {
10008				return it, err
10009			}
10010		}
10011	}
10012
10013	return it, nil
10014}
10015
10016func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10017	var it models.OpenBugInput
10018	var asMap = obj.(map[string]interface{})
10019
10020	for k, v := range asMap {
10021		switch k {
10022		case "clientMutationId":
10023			var err error
10024			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10025			if err != nil {
10026				return it, err
10027			}
10028		case "repoRef":
10029			var err error
10030			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10031			if err != nil {
10032				return it, err
10033			}
10034		case "prefix":
10035			var err error
10036			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10037			if err != nil {
10038				return it, err
10039			}
10040		}
10041	}
10042
10043	return it, nil
10044}
10045
10046func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10047	var it models.SetTitleInput
10048	var asMap = obj.(map[string]interface{})
10049
10050	for k, v := range asMap {
10051		switch k {
10052		case "clientMutationId":
10053			var err error
10054			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10055			if err != nil {
10056				return it, err
10057			}
10058		case "repoRef":
10059			var err error
10060			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10061			if err != nil {
10062				return it, err
10063			}
10064		case "prefix":
10065			var err error
10066			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10067			if err != nil {
10068				return it, err
10069			}
10070		case "title":
10071			var err error
10072			it.Title, err = ec.unmarshalNString2string(ctx, v)
10073			if err != nil {
10074				return it, err
10075			}
10076		}
10077	}
10078
10079	return it, nil
10080}
10081
10082// endregion **************************** input.gotpl *****************************
10083
10084// region    ************************** interface.gotpl ***************************
10085
10086func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10087	switch obj := (obj).(type) {
10088	case nil:
10089		return graphql.Null
10090	case bug.Comment:
10091		return ec._Comment(ctx, sel, &obj)
10092	case *bug.Comment:
10093		if obj == nil {
10094			return graphql.Null
10095		}
10096		return ec._Comment(ctx, sel, obj)
10097	case models.BugWrapper:
10098		if obj == nil {
10099			return graphql.Null
10100		}
10101		return ec._Bug(ctx, sel, obj)
10102	case *bug.CreateOperation:
10103		if obj == nil {
10104			return graphql.Null
10105		}
10106		return ec._CreateOperation(ctx, sel, obj)
10107	case *bug.SetTitleOperation:
10108		if obj == nil {
10109			return graphql.Null
10110		}
10111		return ec._SetTitleOperation(ctx, sel, obj)
10112	case *bug.AddCommentOperation:
10113		if obj == nil {
10114			return graphql.Null
10115		}
10116		return ec._AddCommentOperation(ctx, sel, obj)
10117	case *bug.EditCommentOperation:
10118		if obj == nil {
10119			return graphql.Null
10120		}
10121		return ec._EditCommentOperation(ctx, sel, obj)
10122	case *bug.SetStatusOperation:
10123		if obj == nil {
10124			return graphql.Null
10125		}
10126		return ec._SetStatusOperation(ctx, sel, obj)
10127	case *bug.LabelChangeOperation:
10128		if obj == nil {
10129			return graphql.Null
10130		}
10131		return ec._LabelChangeOperation(ctx, sel, obj)
10132	case *bug.CreateTimelineItem:
10133		if obj == nil {
10134			return graphql.Null
10135		}
10136		return ec._CreateTimelineItem(ctx, sel, obj)
10137	case *bug.AddCommentTimelineItem:
10138		if obj == nil {
10139			return graphql.Null
10140		}
10141		return ec._AddCommentTimelineItem(ctx, sel, obj)
10142	case *bug.LabelChangeTimelineItem:
10143		if obj == nil {
10144			return graphql.Null
10145		}
10146		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10147	case *bug.SetStatusTimelineItem:
10148		if obj == nil {
10149			return graphql.Null
10150		}
10151		return ec._SetStatusTimelineItem(ctx, sel, obj)
10152	case *bug.SetTitleTimelineItem:
10153		if obj == nil {
10154			return graphql.Null
10155		}
10156		return ec._SetTitleTimelineItem(ctx, sel, obj)
10157	default:
10158		panic(fmt.Errorf("unexpected type %T", obj))
10159	}
10160}
10161
10162func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10163	switch obj := (obj).(type) {
10164	case nil:
10165		return graphql.Null
10166	case *bug.CreateOperation:
10167		if obj == nil {
10168			return graphql.Null
10169		}
10170		return ec._CreateOperation(ctx, sel, obj)
10171	case *bug.SetTitleOperation:
10172		if obj == nil {
10173			return graphql.Null
10174		}
10175		return ec._SetTitleOperation(ctx, sel, obj)
10176	case *bug.AddCommentOperation:
10177		if obj == nil {
10178			return graphql.Null
10179		}
10180		return ec._AddCommentOperation(ctx, sel, obj)
10181	case *bug.EditCommentOperation:
10182		if obj == nil {
10183			return graphql.Null
10184		}
10185		return ec._EditCommentOperation(ctx, sel, obj)
10186	case *bug.SetStatusOperation:
10187		if obj == nil {
10188			return graphql.Null
10189		}
10190		return ec._SetStatusOperation(ctx, sel, obj)
10191	case *bug.LabelChangeOperation:
10192		if obj == nil {
10193			return graphql.Null
10194		}
10195		return ec._LabelChangeOperation(ctx, sel, obj)
10196	default:
10197		panic(fmt.Errorf("unexpected type %T", obj))
10198	}
10199}
10200
10201func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10202	switch obj := (obj).(type) {
10203	case nil:
10204		return graphql.Null
10205	case *bug.CreateTimelineItem:
10206		if obj == nil {
10207			return graphql.Null
10208		}
10209		return ec._CreateTimelineItem(ctx, sel, obj)
10210	case *bug.AddCommentTimelineItem:
10211		if obj == nil {
10212			return graphql.Null
10213		}
10214		return ec._AddCommentTimelineItem(ctx, sel, obj)
10215	case bug.LabelChangeTimelineItem:
10216		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10217	case *bug.LabelChangeTimelineItem:
10218		if obj == nil {
10219			return graphql.Null
10220		}
10221		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10222	case bug.SetStatusTimelineItem:
10223		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10224	case *bug.SetStatusTimelineItem:
10225		if obj == nil {
10226			return graphql.Null
10227		}
10228		return ec._SetStatusTimelineItem(ctx, sel, obj)
10229	case bug.SetTitleTimelineItem:
10230		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10231	case *bug.SetTitleTimelineItem:
10232		if obj == nil {
10233			return graphql.Null
10234		}
10235		return ec._SetTitleTimelineItem(ctx, sel, obj)
10236	default:
10237		panic(fmt.Errorf("unexpected type %T", obj))
10238	}
10239}
10240
10241// endregion ************************** interface.gotpl ***************************
10242
10243// region    **************************** object.gotpl ****************************
10244
10245var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10246
10247func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10248	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10249
10250	out := graphql.NewFieldSet(fields)
10251	var invalids uint32
10252	for i, field := range fields {
10253		switch field.Name {
10254		case "__typename":
10255			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10256		case "id":
10257			field := field
10258			out.Concurrently(i, func() (res graphql.Marshaler) {
10259				defer func() {
10260					if r := recover(); r != nil {
10261						ec.Error(ctx, ec.Recover(ctx, r))
10262					}
10263				}()
10264				res = ec._AddCommentOperation_id(ctx, field, obj)
10265				if res == graphql.Null {
10266					atomic.AddUint32(&invalids, 1)
10267				}
10268				return res
10269			})
10270		case "author":
10271			field := field
10272			out.Concurrently(i, func() (res graphql.Marshaler) {
10273				defer func() {
10274					if r := recover(); r != nil {
10275						ec.Error(ctx, ec.Recover(ctx, r))
10276					}
10277				}()
10278				res = ec._AddCommentOperation_author(ctx, field, obj)
10279				if res == graphql.Null {
10280					atomic.AddUint32(&invalids, 1)
10281				}
10282				return res
10283			})
10284		case "date":
10285			field := field
10286			out.Concurrently(i, func() (res graphql.Marshaler) {
10287				defer func() {
10288					if r := recover(); r != nil {
10289						ec.Error(ctx, ec.Recover(ctx, r))
10290					}
10291				}()
10292				res = ec._AddCommentOperation_date(ctx, field, obj)
10293				if res == graphql.Null {
10294					atomic.AddUint32(&invalids, 1)
10295				}
10296				return res
10297			})
10298		case "message":
10299			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10300			if out.Values[i] == graphql.Null {
10301				atomic.AddUint32(&invalids, 1)
10302			}
10303		case "files":
10304			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10305			if out.Values[i] == graphql.Null {
10306				atomic.AddUint32(&invalids, 1)
10307			}
10308		default:
10309			panic("unknown field " + strconv.Quote(field.Name))
10310		}
10311	}
10312	out.Dispatch()
10313	if invalids > 0 {
10314		return graphql.Null
10315	}
10316	return out
10317}
10318
10319var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10320
10321func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10322	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10323
10324	out := graphql.NewFieldSet(fields)
10325	var invalids uint32
10326	for i, field := range fields {
10327		switch field.Name {
10328		case "__typename":
10329			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10330		case "clientMutationId":
10331			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10332		case "bug":
10333			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10334			if out.Values[i] == graphql.Null {
10335				invalids++
10336			}
10337		case "operation":
10338			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10339			if out.Values[i] == graphql.Null {
10340				invalids++
10341			}
10342		default:
10343			panic("unknown field " + strconv.Quote(field.Name))
10344		}
10345	}
10346	out.Dispatch()
10347	if invalids > 0 {
10348		return graphql.Null
10349	}
10350	return out
10351}
10352
10353var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10354
10355func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10356	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10357
10358	out := graphql.NewFieldSet(fields)
10359	var invalids uint32
10360	for i, field := range fields {
10361		switch field.Name {
10362		case "__typename":
10363			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10364		case "id":
10365			field := field
10366			out.Concurrently(i, func() (res graphql.Marshaler) {
10367				defer func() {
10368					if r := recover(); r != nil {
10369						ec.Error(ctx, ec.Recover(ctx, r))
10370					}
10371				}()
10372				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10373				if res == graphql.Null {
10374					atomic.AddUint32(&invalids, 1)
10375				}
10376				return res
10377			})
10378		case "author":
10379			field := field
10380			out.Concurrently(i, func() (res graphql.Marshaler) {
10381				defer func() {
10382					if r := recover(); r != nil {
10383						ec.Error(ctx, ec.Recover(ctx, r))
10384					}
10385				}()
10386				res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10387				if res == graphql.Null {
10388					atomic.AddUint32(&invalids, 1)
10389				}
10390				return res
10391			})
10392		case "message":
10393			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10394			if out.Values[i] == graphql.Null {
10395				atomic.AddUint32(&invalids, 1)
10396			}
10397		case "messageIsEmpty":
10398			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10399			if out.Values[i] == graphql.Null {
10400				atomic.AddUint32(&invalids, 1)
10401			}
10402		case "files":
10403			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10404			if out.Values[i] == graphql.Null {
10405				atomic.AddUint32(&invalids, 1)
10406			}
10407		case "createdAt":
10408			field := field
10409			out.Concurrently(i, func() (res graphql.Marshaler) {
10410				defer func() {
10411					if r := recover(); r != nil {
10412						ec.Error(ctx, ec.Recover(ctx, r))
10413					}
10414				}()
10415				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10416				if res == graphql.Null {
10417					atomic.AddUint32(&invalids, 1)
10418				}
10419				return res
10420			})
10421		case "lastEdit":
10422			field := field
10423			out.Concurrently(i, func() (res graphql.Marshaler) {
10424				defer func() {
10425					if r := recover(); r != nil {
10426						ec.Error(ctx, ec.Recover(ctx, r))
10427					}
10428				}()
10429				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10430				if res == graphql.Null {
10431					atomic.AddUint32(&invalids, 1)
10432				}
10433				return res
10434			})
10435		case "edited":
10436			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10437			if out.Values[i] == graphql.Null {
10438				atomic.AddUint32(&invalids, 1)
10439			}
10440		case "history":
10441			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10442			if out.Values[i] == graphql.Null {
10443				atomic.AddUint32(&invalids, 1)
10444			}
10445		default:
10446			panic("unknown field " + strconv.Quote(field.Name))
10447		}
10448	}
10449	out.Dispatch()
10450	if invalids > 0 {
10451		return graphql.Null
10452	}
10453	return out
10454}
10455
10456var bugImplementors = []string{"Bug", "Authored"}
10457
10458func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10459	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10460
10461	out := graphql.NewFieldSet(fields)
10462	var invalids uint32
10463	for i, field := range fields {
10464		switch field.Name {
10465		case "__typename":
10466			out.Values[i] = graphql.MarshalString("Bug")
10467		case "id":
10468			field := field
10469			out.Concurrently(i, func() (res graphql.Marshaler) {
10470				defer func() {
10471					if r := recover(); r != nil {
10472						ec.Error(ctx, ec.Recover(ctx, r))
10473					}
10474				}()
10475				res = ec._Bug_id(ctx, field, obj)
10476				if res == graphql.Null {
10477					atomic.AddUint32(&invalids, 1)
10478				}
10479				return res
10480			})
10481		case "humanId":
10482			field := field
10483			out.Concurrently(i, func() (res graphql.Marshaler) {
10484				defer func() {
10485					if r := recover(); r != nil {
10486						ec.Error(ctx, ec.Recover(ctx, r))
10487					}
10488				}()
10489				res = ec._Bug_humanId(ctx, field, obj)
10490				if res == graphql.Null {
10491					atomic.AddUint32(&invalids, 1)
10492				}
10493				return res
10494			})
10495		case "status":
10496			field := field
10497			out.Concurrently(i, func() (res graphql.Marshaler) {
10498				defer func() {
10499					if r := recover(); r != nil {
10500						ec.Error(ctx, ec.Recover(ctx, r))
10501					}
10502				}()
10503				res = ec._Bug_status(ctx, field, obj)
10504				if res == graphql.Null {
10505					atomic.AddUint32(&invalids, 1)
10506				}
10507				return res
10508			})
10509		case "title":
10510			out.Values[i] = ec._Bug_title(ctx, field, obj)
10511			if out.Values[i] == graphql.Null {
10512				atomic.AddUint32(&invalids, 1)
10513			}
10514		case "labels":
10515			out.Values[i] = ec._Bug_labels(ctx, field, obj)
10516			if out.Values[i] == graphql.Null {
10517				atomic.AddUint32(&invalids, 1)
10518			}
10519		case "author":
10520			out.Values[i] = ec._Bug_author(ctx, field, obj)
10521			if out.Values[i] == graphql.Null {
10522				atomic.AddUint32(&invalids, 1)
10523			}
10524		case "createdAt":
10525			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10526			if out.Values[i] == graphql.Null {
10527				atomic.AddUint32(&invalids, 1)
10528			}
10529		case "lastEdit":
10530			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10531			if out.Values[i] == graphql.Null {
10532				atomic.AddUint32(&invalids, 1)
10533			}
10534		case "actors":
10535			field := field
10536			out.Concurrently(i, func() (res graphql.Marshaler) {
10537				defer func() {
10538					if r := recover(); r != nil {
10539						ec.Error(ctx, ec.Recover(ctx, r))
10540					}
10541				}()
10542				res = ec._Bug_actors(ctx, field, obj)
10543				if res == graphql.Null {
10544					atomic.AddUint32(&invalids, 1)
10545				}
10546				return res
10547			})
10548		case "participants":
10549			field := field
10550			out.Concurrently(i, func() (res graphql.Marshaler) {
10551				defer func() {
10552					if r := recover(); r != nil {
10553						ec.Error(ctx, ec.Recover(ctx, r))
10554					}
10555				}()
10556				res = ec._Bug_participants(ctx, field, obj)
10557				if res == graphql.Null {
10558					atomic.AddUint32(&invalids, 1)
10559				}
10560				return res
10561			})
10562		case "comments":
10563			field := field
10564			out.Concurrently(i, func() (res graphql.Marshaler) {
10565				defer func() {
10566					if r := recover(); r != nil {
10567						ec.Error(ctx, ec.Recover(ctx, r))
10568					}
10569				}()
10570				res = ec._Bug_comments(ctx, field, obj)
10571				if res == graphql.Null {
10572					atomic.AddUint32(&invalids, 1)
10573				}
10574				return res
10575			})
10576		case "timeline":
10577			field := field
10578			out.Concurrently(i, func() (res graphql.Marshaler) {
10579				defer func() {
10580					if r := recover(); r != nil {
10581						ec.Error(ctx, ec.Recover(ctx, r))
10582					}
10583				}()
10584				res = ec._Bug_timeline(ctx, field, obj)
10585				if res == graphql.Null {
10586					atomic.AddUint32(&invalids, 1)
10587				}
10588				return res
10589			})
10590		case "operations":
10591			field := field
10592			out.Concurrently(i, func() (res graphql.Marshaler) {
10593				defer func() {
10594					if r := recover(); r != nil {
10595						ec.Error(ctx, ec.Recover(ctx, r))
10596					}
10597				}()
10598				res = ec._Bug_operations(ctx, field, obj)
10599				if res == graphql.Null {
10600					atomic.AddUint32(&invalids, 1)
10601				}
10602				return res
10603			})
10604		default:
10605			panic("unknown field " + strconv.Quote(field.Name))
10606		}
10607	}
10608	out.Dispatch()
10609	if invalids > 0 {
10610		return graphql.Null
10611	}
10612	return out
10613}
10614
10615var bugConnectionImplementors = []string{"BugConnection"}
10616
10617func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10618	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10619
10620	out := graphql.NewFieldSet(fields)
10621	var invalids uint32
10622	for i, field := range fields {
10623		switch field.Name {
10624		case "__typename":
10625			out.Values[i] = graphql.MarshalString("BugConnection")
10626		case "edges":
10627			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10628			if out.Values[i] == graphql.Null {
10629				invalids++
10630			}
10631		case "nodes":
10632			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10633			if out.Values[i] == graphql.Null {
10634				invalids++
10635			}
10636		case "pageInfo":
10637			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10638			if out.Values[i] == graphql.Null {
10639				invalids++
10640			}
10641		case "totalCount":
10642			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
10643			if out.Values[i] == graphql.Null {
10644				invalids++
10645			}
10646		default:
10647			panic("unknown field " + strconv.Quote(field.Name))
10648		}
10649	}
10650	out.Dispatch()
10651	if invalids > 0 {
10652		return graphql.Null
10653	}
10654	return out
10655}
10656
10657var bugEdgeImplementors = []string{"BugEdge"}
10658
10659func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
10660	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
10661
10662	out := graphql.NewFieldSet(fields)
10663	var invalids uint32
10664	for i, field := range fields {
10665		switch field.Name {
10666		case "__typename":
10667			out.Values[i] = graphql.MarshalString("BugEdge")
10668		case "cursor":
10669			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
10670			if out.Values[i] == graphql.Null {
10671				invalids++
10672			}
10673		case "node":
10674			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
10675			if out.Values[i] == graphql.Null {
10676				invalids++
10677			}
10678		default:
10679			panic("unknown field " + strconv.Quote(field.Name))
10680		}
10681	}
10682	out.Dispatch()
10683	if invalids > 0 {
10684		return graphql.Null
10685	}
10686	return out
10687}
10688
10689var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
10690
10691func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
10692	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
10693
10694	out := graphql.NewFieldSet(fields)
10695	var invalids uint32
10696	for i, field := range fields {
10697		switch field.Name {
10698		case "__typename":
10699			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
10700		case "clientMutationId":
10701			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
10702		case "bug":
10703			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
10704			if out.Values[i] == graphql.Null {
10705				invalids++
10706			}
10707		case "operation":
10708			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
10709			if out.Values[i] == graphql.Null {
10710				invalids++
10711			}
10712		case "results":
10713			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
10714			if out.Values[i] == graphql.Null {
10715				invalids++
10716			}
10717		default:
10718			panic("unknown field " + strconv.Quote(field.Name))
10719		}
10720	}
10721	out.Dispatch()
10722	if invalids > 0 {
10723		return graphql.Null
10724	}
10725	return out
10726}
10727
10728var closeBugPayloadImplementors = []string{"CloseBugPayload"}
10729
10730func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
10731	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
10732
10733	out := graphql.NewFieldSet(fields)
10734	var invalids uint32
10735	for i, field := range fields {
10736		switch field.Name {
10737		case "__typename":
10738			out.Values[i] = graphql.MarshalString("CloseBugPayload")
10739		case "clientMutationId":
10740			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
10741		case "bug":
10742			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
10743			if out.Values[i] == graphql.Null {
10744				invalids++
10745			}
10746		case "operation":
10747			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
10748			if out.Values[i] == graphql.Null {
10749				invalids++
10750			}
10751		default:
10752			panic("unknown field " + strconv.Quote(field.Name))
10753		}
10754	}
10755	out.Dispatch()
10756	if invalids > 0 {
10757		return graphql.Null
10758	}
10759	return out
10760}
10761
10762var colorImplementors = []string{"Color"}
10763
10764func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
10765	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
10766
10767	out := graphql.NewFieldSet(fields)
10768	var invalids uint32
10769	for i, field := range fields {
10770		switch field.Name {
10771		case "__typename":
10772			out.Values[i] = graphql.MarshalString("Color")
10773		case "R":
10774			field := field
10775			out.Concurrently(i, func() (res graphql.Marshaler) {
10776				defer func() {
10777					if r := recover(); r != nil {
10778						ec.Error(ctx, ec.Recover(ctx, r))
10779					}
10780				}()
10781				res = ec._Color_R(ctx, field, obj)
10782				if res == graphql.Null {
10783					atomic.AddUint32(&invalids, 1)
10784				}
10785				return res
10786			})
10787		case "G":
10788			field := field
10789			out.Concurrently(i, func() (res graphql.Marshaler) {
10790				defer func() {
10791					if r := recover(); r != nil {
10792						ec.Error(ctx, ec.Recover(ctx, r))
10793					}
10794				}()
10795				res = ec._Color_G(ctx, field, obj)
10796				if res == graphql.Null {
10797					atomic.AddUint32(&invalids, 1)
10798				}
10799				return res
10800			})
10801		case "B":
10802			field := field
10803			out.Concurrently(i, func() (res graphql.Marshaler) {
10804				defer func() {
10805					if r := recover(); r != nil {
10806						ec.Error(ctx, ec.Recover(ctx, r))
10807					}
10808				}()
10809				res = ec._Color_B(ctx, field, obj)
10810				if res == graphql.Null {
10811					atomic.AddUint32(&invalids, 1)
10812				}
10813				return res
10814			})
10815		default:
10816			panic("unknown field " + strconv.Quote(field.Name))
10817		}
10818	}
10819	out.Dispatch()
10820	if invalids > 0 {
10821		return graphql.Null
10822	}
10823	return out
10824}
10825
10826var commentImplementors = []string{"Comment", "Authored"}
10827
10828func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
10829	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
10830
10831	out := graphql.NewFieldSet(fields)
10832	var invalids uint32
10833	for i, field := range fields {
10834		switch field.Name {
10835		case "__typename":
10836			out.Values[i] = graphql.MarshalString("Comment")
10837		case "author":
10838			field := field
10839			out.Concurrently(i, func() (res graphql.Marshaler) {
10840				defer func() {
10841					if r := recover(); r != nil {
10842						ec.Error(ctx, ec.Recover(ctx, r))
10843					}
10844				}()
10845				res = ec._Comment_author(ctx, field, obj)
10846				if res == graphql.Null {
10847					atomic.AddUint32(&invalids, 1)
10848				}
10849				return res
10850			})
10851		case "message":
10852			out.Values[i] = ec._Comment_message(ctx, field, obj)
10853			if out.Values[i] == graphql.Null {
10854				atomic.AddUint32(&invalids, 1)
10855			}
10856		case "files":
10857			out.Values[i] = ec._Comment_files(ctx, field, obj)
10858			if out.Values[i] == graphql.Null {
10859				atomic.AddUint32(&invalids, 1)
10860			}
10861		default:
10862			panic("unknown field " + strconv.Quote(field.Name))
10863		}
10864	}
10865	out.Dispatch()
10866	if invalids > 0 {
10867		return graphql.Null
10868	}
10869	return out
10870}
10871
10872var commentConnectionImplementors = []string{"CommentConnection"}
10873
10874func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
10875	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
10876
10877	out := graphql.NewFieldSet(fields)
10878	var invalids uint32
10879	for i, field := range fields {
10880		switch field.Name {
10881		case "__typename":
10882			out.Values[i] = graphql.MarshalString("CommentConnection")
10883		case "edges":
10884			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
10885			if out.Values[i] == graphql.Null {
10886				invalids++
10887			}
10888		case "nodes":
10889			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
10890			if out.Values[i] == graphql.Null {
10891				invalids++
10892			}
10893		case "pageInfo":
10894			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
10895			if out.Values[i] == graphql.Null {
10896				invalids++
10897			}
10898		case "totalCount":
10899			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
10900			if out.Values[i] == graphql.Null {
10901				invalids++
10902			}
10903		default:
10904			panic("unknown field " + strconv.Quote(field.Name))
10905		}
10906	}
10907	out.Dispatch()
10908	if invalids > 0 {
10909		return graphql.Null
10910	}
10911	return out
10912}
10913
10914var commentEdgeImplementors = []string{"CommentEdge"}
10915
10916func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
10917	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
10918
10919	out := graphql.NewFieldSet(fields)
10920	var invalids uint32
10921	for i, field := range fields {
10922		switch field.Name {
10923		case "__typename":
10924			out.Values[i] = graphql.MarshalString("CommentEdge")
10925		case "cursor":
10926			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
10927			if out.Values[i] == graphql.Null {
10928				invalids++
10929			}
10930		case "node":
10931			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
10932			if out.Values[i] == graphql.Null {
10933				invalids++
10934			}
10935		default:
10936			panic("unknown field " + strconv.Quote(field.Name))
10937		}
10938	}
10939	out.Dispatch()
10940	if invalids > 0 {
10941		return graphql.Null
10942	}
10943	return out
10944}
10945
10946var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
10947
10948func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
10949	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
10950
10951	out := graphql.NewFieldSet(fields)
10952	var invalids uint32
10953	for i, field := range fields {
10954		switch field.Name {
10955		case "__typename":
10956			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
10957		case "message":
10958			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
10959			if out.Values[i] == graphql.Null {
10960				atomic.AddUint32(&invalids, 1)
10961			}
10962		case "date":
10963			field := field
10964			out.Concurrently(i, func() (res graphql.Marshaler) {
10965				defer func() {
10966					if r := recover(); r != nil {
10967						ec.Error(ctx, ec.Recover(ctx, r))
10968					}
10969				}()
10970				res = ec._CommentHistoryStep_date(ctx, field, obj)
10971				if res == graphql.Null {
10972					atomic.AddUint32(&invalids, 1)
10973				}
10974				return res
10975			})
10976		default:
10977			panic("unknown field " + strconv.Quote(field.Name))
10978		}
10979	}
10980	out.Dispatch()
10981	if invalids > 0 {
10982		return graphql.Null
10983	}
10984	return out
10985}
10986
10987var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
10988
10989func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
10990	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
10991
10992	out := graphql.NewFieldSet(fields)
10993	var invalids uint32
10994	for i, field := range fields {
10995		switch field.Name {
10996		case "__typename":
10997			out.Values[i] = graphql.MarshalString("CreateOperation")
10998		case "id":
10999			field := field
11000			out.Concurrently(i, func() (res graphql.Marshaler) {
11001				defer func() {
11002					if r := recover(); r != nil {
11003						ec.Error(ctx, ec.Recover(ctx, r))
11004					}
11005				}()
11006				res = ec._CreateOperation_id(ctx, field, obj)
11007				if res == graphql.Null {
11008					atomic.AddUint32(&invalids, 1)
11009				}
11010				return res
11011			})
11012		case "author":
11013			field := field
11014			out.Concurrently(i, func() (res graphql.Marshaler) {
11015				defer func() {
11016					if r := recover(); r != nil {
11017						ec.Error(ctx, ec.Recover(ctx, r))
11018					}
11019				}()
11020				res = ec._CreateOperation_author(ctx, field, obj)
11021				if res == graphql.Null {
11022					atomic.AddUint32(&invalids, 1)
11023				}
11024				return res
11025			})
11026		case "date":
11027			field := field
11028			out.Concurrently(i, func() (res graphql.Marshaler) {
11029				defer func() {
11030					if r := recover(); r != nil {
11031						ec.Error(ctx, ec.Recover(ctx, r))
11032					}
11033				}()
11034				res = ec._CreateOperation_date(ctx, field, obj)
11035				if res == graphql.Null {
11036					atomic.AddUint32(&invalids, 1)
11037				}
11038				return res
11039			})
11040		case "title":
11041			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11042			if out.Values[i] == graphql.Null {
11043				atomic.AddUint32(&invalids, 1)
11044			}
11045		case "message":
11046			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11047			if out.Values[i] == graphql.Null {
11048				atomic.AddUint32(&invalids, 1)
11049			}
11050		case "files":
11051			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11052			if out.Values[i] == graphql.Null {
11053				atomic.AddUint32(&invalids, 1)
11054			}
11055		default:
11056			panic("unknown field " + strconv.Quote(field.Name))
11057		}
11058	}
11059	out.Dispatch()
11060	if invalids > 0 {
11061		return graphql.Null
11062	}
11063	return out
11064}
11065
11066var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11067
11068func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11069	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11070
11071	out := graphql.NewFieldSet(fields)
11072	var invalids uint32
11073	for i, field := range fields {
11074		switch field.Name {
11075		case "__typename":
11076			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11077		case "id":
11078			field := field
11079			out.Concurrently(i, func() (res graphql.Marshaler) {
11080				defer func() {
11081					if r := recover(); r != nil {
11082						ec.Error(ctx, ec.Recover(ctx, r))
11083					}
11084				}()
11085				res = ec._CreateTimelineItem_id(ctx, field, obj)
11086				if res == graphql.Null {
11087					atomic.AddUint32(&invalids, 1)
11088				}
11089				return res
11090			})
11091		case "author":
11092			field := field
11093			out.Concurrently(i, func() (res graphql.Marshaler) {
11094				defer func() {
11095					if r := recover(); r != nil {
11096						ec.Error(ctx, ec.Recover(ctx, r))
11097					}
11098				}()
11099				res = ec._CreateTimelineItem_author(ctx, field, obj)
11100				if res == graphql.Null {
11101					atomic.AddUint32(&invalids, 1)
11102				}
11103				return res
11104			})
11105		case "message":
11106			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11107			if out.Values[i] == graphql.Null {
11108				atomic.AddUint32(&invalids, 1)
11109			}
11110		case "messageIsEmpty":
11111			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11112			if out.Values[i] == graphql.Null {
11113				atomic.AddUint32(&invalids, 1)
11114			}
11115		case "files":
11116			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11117			if out.Values[i] == graphql.Null {
11118				atomic.AddUint32(&invalids, 1)
11119			}
11120		case "createdAt":
11121			field := field
11122			out.Concurrently(i, func() (res graphql.Marshaler) {
11123				defer func() {
11124					if r := recover(); r != nil {
11125						ec.Error(ctx, ec.Recover(ctx, r))
11126					}
11127				}()
11128				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11129				if res == graphql.Null {
11130					atomic.AddUint32(&invalids, 1)
11131				}
11132				return res
11133			})
11134		case "lastEdit":
11135			field := field
11136			out.Concurrently(i, func() (res graphql.Marshaler) {
11137				defer func() {
11138					if r := recover(); r != nil {
11139						ec.Error(ctx, ec.Recover(ctx, r))
11140					}
11141				}()
11142				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11143				if res == graphql.Null {
11144					atomic.AddUint32(&invalids, 1)
11145				}
11146				return res
11147			})
11148		case "edited":
11149			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11150			if out.Values[i] == graphql.Null {
11151				atomic.AddUint32(&invalids, 1)
11152			}
11153		case "history":
11154			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11155			if out.Values[i] == graphql.Null {
11156				atomic.AddUint32(&invalids, 1)
11157			}
11158		default:
11159			panic("unknown field " + strconv.Quote(field.Name))
11160		}
11161	}
11162	out.Dispatch()
11163	if invalids > 0 {
11164		return graphql.Null
11165	}
11166	return out
11167}
11168
11169var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11170
11171func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11172	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11173
11174	out := graphql.NewFieldSet(fields)
11175	var invalids uint32
11176	for i, field := range fields {
11177		switch field.Name {
11178		case "__typename":
11179			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11180		case "id":
11181			field := field
11182			out.Concurrently(i, func() (res graphql.Marshaler) {
11183				defer func() {
11184					if r := recover(); r != nil {
11185						ec.Error(ctx, ec.Recover(ctx, r))
11186					}
11187				}()
11188				res = ec._EditCommentOperation_id(ctx, field, obj)
11189				if res == graphql.Null {
11190					atomic.AddUint32(&invalids, 1)
11191				}
11192				return res
11193			})
11194		case "author":
11195			field := field
11196			out.Concurrently(i, func() (res graphql.Marshaler) {
11197				defer func() {
11198					if r := recover(); r != nil {
11199						ec.Error(ctx, ec.Recover(ctx, r))
11200					}
11201				}()
11202				res = ec._EditCommentOperation_author(ctx, field, obj)
11203				if res == graphql.Null {
11204					atomic.AddUint32(&invalids, 1)
11205				}
11206				return res
11207			})
11208		case "date":
11209			field := field
11210			out.Concurrently(i, func() (res graphql.Marshaler) {
11211				defer func() {
11212					if r := recover(); r != nil {
11213						ec.Error(ctx, ec.Recover(ctx, r))
11214					}
11215				}()
11216				res = ec._EditCommentOperation_date(ctx, field, obj)
11217				if res == graphql.Null {
11218					atomic.AddUint32(&invalids, 1)
11219				}
11220				return res
11221			})
11222		case "target":
11223			field := field
11224			out.Concurrently(i, func() (res graphql.Marshaler) {
11225				defer func() {
11226					if r := recover(); r != nil {
11227						ec.Error(ctx, ec.Recover(ctx, r))
11228					}
11229				}()
11230				res = ec._EditCommentOperation_target(ctx, field, obj)
11231				if res == graphql.Null {
11232					atomic.AddUint32(&invalids, 1)
11233				}
11234				return res
11235			})
11236		case "message":
11237			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11238			if out.Values[i] == graphql.Null {
11239				atomic.AddUint32(&invalids, 1)
11240			}
11241		case "files":
11242			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11243			if out.Values[i] == graphql.Null {
11244				atomic.AddUint32(&invalids, 1)
11245			}
11246		default:
11247			panic("unknown field " + strconv.Quote(field.Name))
11248		}
11249	}
11250	out.Dispatch()
11251	if invalids > 0 {
11252		return graphql.Null
11253	}
11254	return out
11255}
11256
11257var identityImplementors = []string{"Identity"}
11258
11259func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11260	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11261
11262	out := graphql.NewFieldSet(fields)
11263	var invalids uint32
11264	for i, field := range fields {
11265		switch field.Name {
11266		case "__typename":
11267			out.Values[i] = graphql.MarshalString("Identity")
11268		case "id":
11269			field := field
11270			out.Concurrently(i, func() (res graphql.Marshaler) {
11271				defer func() {
11272					if r := recover(); r != nil {
11273						ec.Error(ctx, ec.Recover(ctx, r))
11274					}
11275				}()
11276				res = ec._Identity_id(ctx, field, obj)
11277				if res == graphql.Null {
11278					atomic.AddUint32(&invalids, 1)
11279				}
11280				return res
11281			})
11282		case "humanId":
11283			field := field
11284			out.Concurrently(i, func() (res graphql.Marshaler) {
11285				defer func() {
11286					if r := recover(); r != nil {
11287						ec.Error(ctx, ec.Recover(ctx, r))
11288					}
11289				}()
11290				res = ec._Identity_humanId(ctx, field, obj)
11291				if res == graphql.Null {
11292					atomic.AddUint32(&invalids, 1)
11293				}
11294				return res
11295			})
11296		case "name":
11297			out.Values[i] = ec._Identity_name(ctx, field, obj)
11298		case "email":
11299			out.Values[i] = ec._Identity_email(ctx, field, obj)
11300		case "login":
11301			out.Values[i] = ec._Identity_login(ctx, field, obj)
11302		case "displayName":
11303			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11304			if out.Values[i] == graphql.Null {
11305				atomic.AddUint32(&invalids, 1)
11306			}
11307		case "avatarUrl":
11308			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11309		case "isProtected":
11310			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11311			if out.Values[i] == graphql.Null {
11312				atomic.AddUint32(&invalids, 1)
11313			}
11314		default:
11315			panic("unknown field " + strconv.Quote(field.Name))
11316		}
11317	}
11318	out.Dispatch()
11319	if invalids > 0 {
11320		return graphql.Null
11321	}
11322	return out
11323}
11324
11325var identityConnectionImplementors = []string{"IdentityConnection"}
11326
11327func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11328	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11329
11330	out := graphql.NewFieldSet(fields)
11331	var invalids uint32
11332	for i, field := range fields {
11333		switch field.Name {
11334		case "__typename":
11335			out.Values[i] = graphql.MarshalString("IdentityConnection")
11336		case "edges":
11337			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11338			if out.Values[i] == graphql.Null {
11339				invalids++
11340			}
11341		case "nodes":
11342			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11343			if out.Values[i] == graphql.Null {
11344				invalids++
11345			}
11346		case "pageInfo":
11347			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11348			if out.Values[i] == graphql.Null {
11349				invalids++
11350			}
11351		case "totalCount":
11352			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11353			if out.Values[i] == graphql.Null {
11354				invalids++
11355			}
11356		default:
11357			panic("unknown field " + strconv.Quote(field.Name))
11358		}
11359	}
11360	out.Dispatch()
11361	if invalids > 0 {
11362		return graphql.Null
11363	}
11364	return out
11365}
11366
11367var identityEdgeImplementors = []string{"IdentityEdge"}
11368
11369func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11370	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11371
11372	out := graphql.NewFieldSet(fields)
11373	var invalids uint32
11374	for i, field := range fields {
11375		switch field.Name {
11376		case "__typename":
11377			out.Values[i] = graphql.MarshalString("IdentityEdge")
11378		case "cursor":
11379			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11380			if out.Values[i] == graphql.Null {
11381				invalids++
11382			}
11383		case "node":
11384			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11385			if out.Values[i] == graphql.Null {
11386				invalids++
11387			}
11388		default:
11389			panic("unknown field " + strconv.Quote(field.Name))
11390		}
11391	}
11392	out.Dispatch()
11393	if invalids > 0 {
11394		return graphql.Null
11395	}
11396	return out
11397}
11398
11399var labelImplementors = []string{"Label"}
11400
11401func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11402	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11403
11404	out := graphql.NewFieldSet(fields)
11405	var invalids uint32
11406	for i, field := range fields {
11407		switch field.Name {
11408		case "__typename":
11409			out.Values[i] = graphql.MarshalString("Label")
11410		case "name":
11411			field := field
11412			out.Concurrently(i, func() (res graphql.Marshaler) {
11413				defer func() {
11414					if r := recover(); r != nil {
11415						ec.Error(ctx, ec.Recover(ctx, r))
11416					}
11417				}()
11418				res = ec._Label_name(ctx, field, obj)
11419				if res == graphql.Null {
11420					atomic.AddUint32(&invalids, 1)
11421				}
11422				return res
11423			})
11424		case "color":
11425			field := field
11426			out.Concurrently(i, func() (res graphql.Marshaler) {
11427				defer func() {
11428					if r := recover(); r != nil {
11429						ec.Error(ctx, ec.Recover(ctx, r))
11430					}
11431				}()
11432				res = ec._Label_color(ctx, field, obj)
11433				if res == graphql.Null {
11434					atomic.AddUint32(&invalids, 1)
11435				}
11436				return res
11437			})
11438		default:
11439			panic("unknown field " + strconv.Quote(field.Name))
11440		}
11441	}
11442	out.Dispatch()
11443	if invalids > 0 {
11444		return graphql.Null
11445	}
11446	return out
11447}
11448
11449var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11450
11451func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11452	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11453
11454	out := graphql.NewFieldSet(fields)
11455	var invalids uint32
11456	for i, field := range fields {
11457		switch field.Name {
11458		case "__typename":
11459			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11460		case "id":
11461			field := field
11462			out.Concurrently(i, func() (res graphql.Marshaler) {
11463				defer func() {
11464					if r := recover(); r != nil {
11465						ec.Error(ctx, ec.Recover(ctx, r))
11466					}
11467				}()
11468				res = ec._LabelChangeOperation_id(ctx, field, obj)
11469				if res == graphql.Null {
11470					atomic.AddUint32(&invalids, 1)
11471				}
11472				return res
11473			})
11474		case "author":
11475			field := field
11476			out.Concurrently(i, func() (res graphql.Marshaler) {
11477				defer func() {
11478					if r := recover(); r != nil {
11479						ec.Error(ctx, ec.Recover(ctx, r))
11480					}
11481				}()
11482				res = ec._LabelChangeOperation_author(ctx, field, obj)
11483				if res == graphql.Null {
11484					atomic.AddUint32(&invalids, 1)
11485				}
11486				return res
11487			})
11488		case "date":
11489			field := field
11490			out.Concurrently(i, func() (res graphql.Marshaler) {
11491				defer func() {
11492					if r := recover(); r != nil {
11493						ec.Error(ctx, ec.Recover(ctx, r))
11494					}
11495				}()
11496				res = ec._LabelChangeOperation_date(ctx, field, obj)
11497				if res == graphql.Null {
11498					atomic.AddUint32(&invalids, 1)
11499				}
11500				return res
11501			})
11502		case "added":
11503			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11504			if out.Values[i] == graphql.Null {
11505				atomic.AddUint32(&invalids, 1)
11506			}
11507		case "removed":
11508			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11509			if out.Values[i] == graphql.Null {
11510				atomic.AddUint32(&invalids, 1)
11511			}
11512		default:
11513			panic("unknown field " + strconv.Quote(field.Name))
11514		}
11515	}
11516	out.Dispatch()
11517	if invalids > 0 {
11518		return graphql.Null
11519	}
11520	return out
11521}
11522
11523var labelChangeResultImplementors = []string{"LabelChangeResult"}
11524
11525func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11526	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11527
11528	out := graphql.NewFieldSet(fields)
11529	var invalids uint32
11530	for i, field := range fields {
11531		switch field.Name {
11532		case "__typename":
11533			out.Values[i] = graphql.MarshalString("LabelChangeResult")
11534		case "label":
11535			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11536			if out.Values[i] == graphql.Null {
11537				atomic.AddUint32(&invalids, 1)
11538			}
11539		case "status":
11540			field := field
11541			out.Concurrently(i, func() (res graphql.Marshaler) {
11542				defer func() {
11543					if r := recover(); r != nil {
11544						ec.Error(ctx, ec.Recover(ctx, r))
11545					}
11546				}()
11547				res = ec._LabelChangeResult_status(ctx, field, obj)
11548				if res == graphql.Null {
11549					atomic.AddUint32(&invalids, 1)
11550				}
11551				return res
11552			})
11553		default:
11554			panic("unknown field " + strconv.Quote(field.Name))
11555		}
11556	}
11557	out.Dispatch()
11558	if invalids > 0 {
11559		return graphql.Null
11560	}
11561	return out
11562}
11563
11564var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11565
11566func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11567	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11568
11569	out := graphql.NewFieldSet(fields)
11570	var invalids uint32
11571	for i, field := range fields {
11572		switch field.Name {
11573		case "__typename":
11574			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11575		case "id":
11576			field := field
11577			out.Concurrently(i, func() (res graphql.Marshaler) {
11578				defer func() {
11579					if r := recover(); r != nil {
11580						ec.Error(ctx, ec.Recover(ctx, r))
11581					}
11582				}()
11583				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11584				if res == graphql.Null {
11585					atomic.AddUint32(&invalids, 1)
11586				}
11587				return res
11588			})
11589		case "author":
11590			field := field
11591			out.Concurrently(i, func() (res graphql.Marshaler) {
11592				defer func() {
11593					if r := recover(); r != nil {
11594						ec.Error(ctx, ec.Recover(ctx, r))
11595					}
11596				}()
11597				res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
11598				if res == graphql.Null {
11599					atomic.AddUint32(&invalids, 1)
11600				}
11601				return res
11602			})
11603		case "date":
11604			field := field
11605			out.Concurrently(i, func() (res graphql.Marshaler) {
11606				defer func() {
11607					if r := recover(); r != nil {
11608						ec.Error(ctx, ec.Recover(ctx, r))
11609					}
11610				}()
11611				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
11612				if res == graphql.Null {
11613					atomic.AddUint32(&invalids, 1)
11614				}
11615				return res
11616			})
11617		case "added":
11618			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
11619			if out.Values[i] == graphql.Null {
11620				atomic.AddUint32(&invalids, 1)
11621			}
11622		case "removed":
11623			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
11624			if out.Values[i] == graphql.Null {
11625				atomic.AddUint32(&invalids, 1)
11626			}
11627		default:
11628			panic("unknown field " + strconv.Quote(field.Name))
11629		}
11630	}
11631	out.Dispatch()
11632	if invalids > 0 {
11633		return graphql.Null
11634	}
11635	return out
11636}
11637
11638var labelConnectionImplementors = []string{"LabelConnection"}
11639
11640func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
11641	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
11642
11643	out := graphql.NewFieldSet(fields)
11644	var invalids uint32
11645	for i, field := range fields {
11646		switch field.Name {
11647		case "__typename":
11648			out.Values[i] = graphql.MarshalString("LabelConnection")
11649		case "edges":
11650			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
11651			if out.Values[i] == graphql.Null {
11652				invalids++
11653			}
11654		case "nodes":
11655			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
11656			if out.Values[i] == graphql.Null {
11657				invalids++
11658			}
11659		case "pageInfo":
11660			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
11661			if out.Values[i] == graphql.Null {
11662				invalids++
11663			}
11664		case "totalCount":
11665			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
11666			if out.Values[i] == graphql.Null {
11667				invalids++
11668			}
11669		default:
11670			panic("unknown field " + strconv.Quote(field.Name))
11671		}
11672	}
11673	out.Dispatch()
11674	if invalids > 0 {
11675		return graphql.Null
11676	}
11677	return out
11678}
11679
11680var labelEdgeImplementors = []string{"LabelEdge"}
11681
11682func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
11683	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
11684
11685	out := graphql.NewFieldSet(fields)
11686	var invalids uint32
11687	for i, field := range fields {
11688		switch field.Name {
11689		case "__typename":
11690			out.Values[i] = graphql.MarshalString("LabelEdge")
11691		case "cursor":
11692			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
11693			if out.Values[i] == graphql.Null {
11694				invalids++
11695			}
11696		case "node":
11697			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
11698			if out.Values[i] == graphql.Null {
11699				invalids++
11700			}
11701		default:
11702			panic("unknown field " + strconv.Quote(field.Name))
11703		}
11704	}
11705	out.Dispatch()
11706	if invalids > 0 {
11707		return graphql.Null
11708	}
11709	return out
11710}
11711
11712var mutationImplementors = []string{"Mutation"}
11713
11714func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11715	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
11716
11717	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11718		Object: "Mutation",
11719	})
11720
11721	out := graphql.NewFieldSet(fields)
11722	var invalids uint32
11723	for i, field := range fields {
11724		switch field.Name {
11725		case "__typename":
11726			out.Values[i] = graphql.MarshalString("Mutation")
11727		case "newBug":
11728			out.Values[i] = ec._Mutation_newBug(ctx, field)
11729			if out.Values[i] == graphql.Null {
11730				invalids++
11731			}
11732		case "addComment":
11733			out.Values[i] = ec._Mutation_addComment(ctx, field)
11734			if out.Values[i] == graphql.Null {
11735				invalids++
11736			}
11737		case "changeLabels":
11738			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
11739			if out.Values[i] == graphql.Null {
11740				invalids++
11741			}
11742		case "openBug":
11743			out.Values[i] = ec._Mutation_openBug(ctx, field)
11744			if out.Values[i] == graphql.Null {
11745				invalids++
11746			}
11747		case "closeBug":
11748			out.Values[i] = ec._Mutation_closeBug(ctx, field)
11749			if out.Values[i] == graphql.Null {
11750				invalids++
11751			}
11752		case "setTitle":
11753			out.Values[i] = ec._Mutation_setTitle(ctx, field)
11754			if out.Values[i] == graphql.Null {
11755				invalids++
11756			}
11757		default:
11758			panic("unknown field " + strconv.Quote(field.Name))
11759		}
11760	}
11761	out.Dispatch()
11762	if invalids > 0 {
11763		return graphql.Null
11764	}
11765	return out
11766}
11767
11768var newBugPayloadImplementors = []string{"NewBugPayload"}
11769
11770func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
11771	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
11772
11773	out := graphql.NewFieldSet(fields)
11774	var invalids uint32
11775	for i, field := range fields {
11776		switch field.Name {
11777		case "__typename":
11778			out.Values[i] = graphql.MarshalString("NewBugPayload")
11779		case "clientMutationId":
11780			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
11781		case "bug":
11782			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
11783			if out.Values[i] == graphql.Null {
11784				invalids++
11785			}
11786		case "operation":
11787			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
11788			if out.Values[i] == graphql.Null {
11789				invalids++
11790			}
11791		default:
11792			panic("unknown field " + strconv.Quote(field.Name))
11793		}
11794	}
11795	out.Dispatch()
11796	if invalids > 0 {
11797		return graphql.Null
11798	}
11799	return out
11800}
11801
11802var openBugPayloadImplementors = []string{"OpenBugPayload"}
11803
11804func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
11805	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
11806
11807	out := graphql.NewFieldSet(fields)
11808	var invalids uint32
11809	for i, field := range fields {
11810		switch field.Name {
11811		case "__typename":
11812			out.Values[i] = graphql.MarshalString("OpenBugPayload")
11813		case "clientMutationId":
11814			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
11815		case "bug":
11816			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
11817			if out.Values[i] == graphql.Null {
11818				invalids++
11819			}
11820		case "operation":
11821			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
11822			if out.Values[i] == graphql.Null {
11823				invalids++
11824			}
11825		default:
11826			panic("unknown field " + strconv.Quote(field.Name))
11827		}
11828	}
11829	out.Dispatch()
11830	if invalids > 0 {
11831		return graphql.Null
11832	}
11833	return out
11834}
11835
11836var operationConnectionImplementors = []string{"OperationConnection"}
11837
11838func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
11839	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
11840
11841	out := graphql.NewFieldSet(fields)
11842	var invalids uint32
11843	for i, field := range fields {
11844		switch field.Name {
11845		case "__typename":
11846			out.Values[i] = graphql.MarshalString("OperationConnection")
11847		case "edges":
11848			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
11849			if out.Values[i] == graphql.Null {
11850				invalids++
11851			}
11852		case "nodes":
11853			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
11854			if out.Values[i] == graphql.Null {
11855				invalids++
11856			}
11857		case "pageInfo":
11858			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
11859			if out.Values[i] == graphql.Null {
11860				invalids++
11861			}
11862		case "totalCount":
11863			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
11864			if out.Values[i] == graphql.Null {
11865				invalids++
11866			}
11867		default:
11868			panic("unknown field " + strconv.Quote(field.Name))
11869		}
11870	}
11871	out.Dispatch()
11872	if invalids > 0 {
11873		return graphql.Null
11874	}
11875	return out
11876}
11877
11878var operationEdgeImplementors = []string{"OperationEdge"}
11879
11880func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
11881	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
11882
11883	out := graphql.NewFieldSet(fields)
11884	var invalids uint32
11885	for i, field := range fields {
11886		switch field.Name {
11887		case "__typename":
11888			out.Values[i] = graphql.MarshalString("OperationEdge")
11889		case "cursor":
11890			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
11891			if out.Values[i] == graphql.Null {
11892				invalids++
11893			}
11894		case "node":
11895			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
11896			if out.Values[i] == graphql.Null {
11897				invalids++
11898			}
11899		default:
11900			panic("unknown field " + strconv.Quote(field.Name))
11901		}
11902	}
11903	out.Dispatch()
11904	if invalids > 0 {
11905		return graphql.Null
11906	}
11907	return out
11908}
11909
11910var pageInfoImplementors = []string{"PageInfo"}
11911
11912func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
11913	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
11914
11915	out := graphql.NewFieldSet(fields)
11916	var invalids uint32
11917	for i, field := range fields {
11918		switch field.Name {
11919		case "__typename":
11920			out.Values[i] = graphql.MarshalString("PageInfo")
11921		case "hasNextPage":
11922			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
11923			if out.Values[i] == graphql.Null {
11924				invalids++
11925			}
11926		case "hasPreviousPage":
11927			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
11928			if out.Values[i] == graphql.Null {
11929				invalids++
11930			}
11931		case "startCursor":
11932			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
11933			if out.Values[i] == graphql.Null {
11934				invalids++
11935			}
11936		case "endCursor":
11937			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
11938			if out.Values[i] == graphql.Null {
11939				invalids++
11940			}
11941		default:
11942			panic("unknown field " + strconv.Quote(field.Name))
11943		}
11944	}
11945	out.Dispatch()
11946	if invalids > 0 {
11947		return graphql.Null
11948	}
11949	return out
11950}
11951
11952var queryImplementors = []string{"Query"}
11953
11954func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11955	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
11956
11957	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11958		Object: "Query",
11959	})
11960
11961	out := graphql.NewFieldSet(fields)
11962	var invalids uint32
11963	for i, field := range fields {
11964		switch field.Name {
11965		case "__typename":
11966			out.Values[i] = graphql.MarshalString("Query")
11967		case "repository":
11968			field := field
11969			out.Concurrently(i, func() (res graphql.Marshaler) {
11970				defer func() {
11971					if r := recover(); r != nil {
11972						ec.Error(ctx, ec.Recover(ctx, r))
11973					}
11974				}()
11975				res = ec._Query_repository(ctx, field)
11976				return res
11977			})
11978		case "__type":
11979			out.Values[i] = ec._Query___type(ctx, field)
11980		case "__schema":
11981			out.Values[i] = ec._Query___schema(ctx, field)
11982		default:
11983			panic("unknown field " + strconv.Quote(field.Name))
11984		}
11985	}
11986	out.Dispatch()
11987	if invalids > 0 {
11988		return graphql.Null
11989	}
11990	return out
11991}
11992
11993var repositoryImplementors = []string{"Repository"}
11994
11995func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
11996	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
11997
11998	out := graphql.NewFieldSet(fields)
11999	var invalids uint32
12000	for i, field := range fields {
12001		switch field.Name {
12002		case "__typename":
12003			out.Values[i] = graphql.MarshalString("Repository")
12004		case "name":
12005			field := field
12006			out.Concurrently(i, func() (res graphql.Marshaler) {
12007				defer func() {
12008					if r := recover(); r != nil {
12009						ec.Error(ctx, ec.Recover(ctx, r))
12010					}
12011				}()
12012				res = ec._Repository_name(ctx, field, obj)
12013				return res
12014			})
12015		case "allBugs":
12016			field := field
12017			out.Concurrently(i, func() (res graphql.Marshaler) {
12018				defer func() {
12019					if r := recover(); r != nil {
12020						ec.Error(ctx, ec.Recover(ctx, r))
12021					}
12022				}()
12023				res = ec._Repository_allBugs(ctx, field, obj)
12024				if res == graphql.Null {
12025					atomic.AddUint32(&invalids, 1)
12026				}
12027				return res
12028			})
12029		case "bug":
12030			field := field
12031			out.Concurrently(i, func() (res graphql.Marshaler) {
12032				defer func() {
12033					if r := recover(); r != nil {
12034						ec.Error(ctx, ec.Recover(ctx, r))
12035					}
12036				}()
12037				res = ec._Repository_bug(ctx, field, obj)
12038				return res
12039			})
12040		case "allIdentities":
12041			field := field
12042			out.Concurrently(i, func() (res graphql.Marshaler) {
12043				defer func() {
12044					if r := recover(); r != nil {
12045						ec.Error(ctx, ec.Recover(ctx, r))
12046					}
12047				}()
12048				res = ec._Repository_allIdentities(ctx, field, obj)
12049				if res == graphql.Null {
12050					atomic.AddUint32(&invalids, 1)
12051				}
12052				return res
12053			})
12054		case "identity":
12055			field := field
12056			out.Concurrently(i, func() (res graphql.Marshaler) {
12057				defer func() {
12058					if r := recover(); r != nil {
12059						ec.Error(ctx, ec.Recover(ctx, r))
12060					}
12061				}()
12062				res = ec._Repository_identity(ctx, field, obj)
12063				return res
12064			})
12065		case "userIdentity":
12066			field := field
12067			out.Concurrently(i, func() (res graphql.Marshaler) {
12068				defer func() {
12069					if r := recover(); r != nil {
12070						ec.Error(ctx, ec.Recover(ctx, r))
12071					}
12072				}()
12073				res = ec._Repository_userIdentity(ctx, field, obj)
12074				return res
12075			})
12076		case "validLabels":
12077			field := field
12078			out.Concurrently(i, func() (res graphql.Marshaler) {
12079				defer func() {
12080					if r := recover(); r != nil {
12081						ec.Error(ctx, ec.Recover(ctx, r))
12082					}
12083				}()
12084				res = ec._Repository_validLabels(ctx, field, obj)
12085				if res == graphql.Null {
12086					atomic.AddUint32(&invalids, 1)
12087				}
12088				return res
12089			})
12090		default:
12091			panic("unknown field " + strconv.Quote(field.Name))
12092		}
12093	}
12094	out.Dispatch()
12095	if invalids > 0 {
12096		return graphql.Null
12097	}
12098	return out
12099}
12100
12101var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12102
12103func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12104	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12105
12106	out := graphql.NewFieldSet(fields)
12107	var invalids uint32
12108	for i, field := range fields {
12109		switch field.Name {
12110		case "__typename":
12111			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12112		case "id":
12113			field := field
12114			out.Concurrently(i, func() (res graphql.Marshaler) {
12115				defer func() {
12116					if r := recover(); r != nil {
12117						ec.Error(ctx, ec.Recover(ctx, r))
12118					}
12119				}()
12120				res = ec._SetStatusOperation_id(ctx, field, obj)
12121				if res == graphql.Null {
12122					atomic.AddUint32(&invalids, 1)
12123				}
12124				return res
12125			})
12126		case "author":
12127			field := field
12128			out.Concurrently(i, func() (res graphql.Marshaler) {
12129				defer func() {
12130					if r := recover(); r != nil {
12131						ec.Error(ctx, ec.Recover(ctx, r))
12132					}
12133				}()
12134				res = ec._SetStatusOperation_author(ctx, field, obj)
12135				if res == graphql.Null {
12136					atomic.AddUint32(&invalids, 1)
12137				}
12138				return res
12139			})
12140		case "date":
12141			field := field
12142			out.Concurrently(i, func() (res graphql.Marshaler) {
12143				defer func() {
12144					if r := recover(); r != nil {
12145						ec.Error(ctx, ec.Recover(ctx, r))
12146					}
12147				}()
12148				res = ec._SetStatusOperation_date(ctx, field, obj)
12149				if res == graphql.Null {
12150					atomic.AddUint32(&invalids, 1)
12151				}
12152				return res
12153			})
12154		case "status":
12155			field := field
12156			out.Concurrently(i, func() (res graphql.Marshaler) {
12157				defer func() {
12158					if r := recover(); r != nil {
12159						ec.Error(ctx, ec.Recover(ctx, r))
12160					}
12161				}()
12162				res = ec._SetStatusOperation_status(ctx, field, obj)
12163				if res == graphql.Null {
12164					atomic.AddUint32(&invalids, 1)
12165				}
12166				return res
12167			})
12168		default:
12169			panic("unknown field " + strconv.Quote(field.Name))
12170		}
12171	}
12172	out.Dispatch()
12173	if invalids > 0 {
12174		return graphql.Null
12175	}
12176	return out
12177}
12178
12179var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12180
12181func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12182	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12183
12184	out := graphql.NewFieldSet(fields)
12185	var invalids uint32
12186	for i, field := range fields {
12187		switch field.Name {
12188		case "__typename":
12189			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12190		case "id":
12191			field := field
12192			out.Concurrently(i, func() (res graphql.Marshaler) {
12193				defer func() {
12194					if r := recover(); r != nil {
12195						ec.Error(ctx, ec.Recover(ctx, r))
12196					}
12197				}()
12198				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12199				if res == graphql.Null {
12200					atomic.AddUint32(&invalids, 1)
12201				}
12202				return res
12203			})
12204		case "author":
12205			field := field
12206			out.Concurrently(i, func() (res graphql.Marshaler) {
12207				defer func() {
12208					if r := recover(); r != nil {
12209						ec.Error(ctx, ec.Recover(ctx, r))
12210					}
12211				}()
12212				res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12213				if res == graphql.Null {
12214					atomic.AddUint32(&invalids, 1)
12215				}
12216				return res
12217			})
12218		case "date":
12219			field := field
12220			out.Concurrently(i, func() (res graphql.Marshaler) {
12221				defer func() {
12222					if r := recover(); r != nil {
12223						ec.Error(ctx, ec.Recover(ctx, r))
12224					}
12225				}()
12226				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12227				if res == graphql.Null {
12228					atomic.AddUint32(&invalids, 1)
12229				}
12230				return res
12231			})
12232		case "status":
12233			field := field
12234			out.Concurrently(i, func() (res graphql.Marshaler) {
12235				defer func() {
12236					if r := recover(); r != nil {
12237						ec.Error(ctx, ec.Recover(ctx, r))
12238					}
12239				}()
12240				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12241				if res == graphql.Null {
12242					atomic.AddUint32(&invalids, 1)
12243				}
12244				return res
12245			})
12246		default:
12247			panic("unknown field " + strconv.Quote(field.Name))
12248		}
12249	}
12250	out.Dispatch()
12251	if invalids > 0 {
12252		return graphql.Null
12253	}
12254	return out
12255}
12256
12257var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12258
12259func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12260	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12261
12262	out := graphql.NewFieldSet(fields)
12263	var invalids uint32
12264	for i, field := range fields {
12265		switch field.Name {
12266		case "__typename":
12267			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12268		case "id":
12269			field := field
12270			out.Concurrently(i, func() (res graphql.Marshaler) {
12271				defer func() {
12272					if r := recover(); r != nil {
12273						ec.Error(ctx, ec.Recover(ctx, r))
12274					}
12275				}()
12276				res = ec._SetTitleOperation_id(ctx, field, obj)
12277				if res == graphql.Null {
12278					atomic.AddUint32(&invalids, 1)
12279				}
12280				return res
12281			})
12282		case "author":
12283			field := field
12284			out.Concurrently(i, func() (res graphql.Marshaler) {
12285				defer func() {
12286					if r := recover(); r != nil {
12287						ec.Error(ctx, ec.Recover(ctx, r))
12288					}
12289				}()
12290				res = ec._SetTitleOperation_author(ctx, field, obj)
12291				if res == graphql.Null {
12292					atomic.AddUint32(&invalids, 1)
12293				}
12294				return res
12295			})
12296		case "date":
12297			field := field
12298			out.Concurrently(i, func() (res graphql.Marshaler) {
12299				defer func() {
12300					if r := recover(); r != nil {
12301						ec.Error(ctx, ec.Recover(ctx, r))
12302					}
12303				}()
12304				res = ec._SetTitleOperation_date(ctx, field, obj)
12305				if res == graphql.Null {
12306					atomic.AddUint32(&invalids, 1)
12307				}
12308				return res
12309			})
12310		case "title":
12311			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12312			if out.Values[i] == graphql.Null {
12313				atomic.AddUint32(&invalids, 1)
12314			}
12315		case "was":
12316			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12317			if out.Values[i] == graphql.Null {
12318				atomic.AddUint32(&invalids, 1)
12319			}
12320		default:
12321			panic("unknown field " + strconv.Quote(field.Name))
12322		}
12323	}
12324	out.Dispatch()
12325	if invalids > 0 {
12326		return graphql.Null
12327	}
12328	return out
12329}
12330
12331var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12332
12333func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12334	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12335
12336	out := graphql.NewFieldSet(fields)
12337	var invalids uint32
12338	for i, field := range fields {
12339		switch field.Name {
12340		case "__typename":
12341			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12342		case "clientMutationId":
12343			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12344		case "bug":
12345			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12346			if out.Values[i] == graphql.Null {
12347				invalids++
12348			}
12349		case "operation":
12350			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12351			if out.Values[i] == graphql.Null {
12352				invalids++
12353			}
12354		default:
12355			panic("unknown field " + strconv.Quote(field.Name))
12356		}
12357	}
12358	out.Dispatch()
12359	if invalids > 0 {
12360		return graphql.Null
12361	}
12362	return out
12363}
12364
12365var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12366
12367func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12368	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12369
12370	out := graphql.NewFieldSet(fields)
12371	var invalids uint32
12372	for i, field := range fields {
12373		switch field.Name {
12374		case "__typename":
12375			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12376		case "id":
12377			field := field
12378			out.Concurrently(i, func() (res graphql.Marshaler) {
12379				defer func() {
12380					if r := recover(); r != nil {
12381						ec.Error(ctx, ec.Recover(ctx, r))
12382					}
12383				}()
12384				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12385				if res == graphql.Null {
12386					atomic.AddUint32(&invalids, 1)
12387				}
12388				return res
12389			})
12390		case "author":
12391			field := field
12392			out.Concurrently(i, func() (res graphql.Marshaler) {
12393				defer func() {
12394					if r := recover(); r != nil {
12395						ec.Error(ctx, ec.Recover(ctx, r))
12396					}
12397				}()
12398				res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12399				if res == graphql.Null {
12400					atomic.AddUint32(&invalids, 1)
12401				}
12402				return res
12403			})
12404		case "date":
12405			field := field
12406			out.Concurrently(i, func() (res graphql.Marshaler) {
12407				defer func() {
12408					if r := recover(); r != nil {
12409						ec.Error(ctx, ec.Recover(ctx, r))
12410					}
12411				}()
12412				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12413				if res == graphql.Null {
12414					atomic.AddUint32(&invalids, 1)
12415				}
12416				return res
12417			})
12418		case "title":
12419			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12420			if out.Values[i] == graphql.Null {
12421				atomic.AddUint32(&invalids, 1)
12422			}
12423		case "was":
12424			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12425			if out.Values[i] == graphql.Null {
12426				atomic.AddUint32(&invalids, 1)
12427			}
12428		default:
12429			panic("unknown field " + strconv.Quote(field.Name))
12430		}
12431	}
12432	out.Dispatch()
12433	if invalids > 0 {
12434		return graphql.Null
12435	}
12436	return out
12437}
12438
12439var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12440
12441func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12442	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12443
12444	out := graphql.NewFieldSet(fields)
12445	var invalids uint32
12446	for i, field := range fields {
12447		switch field.Name {
12448		case "__typename":
12449			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12450		case "edges":
12451			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12452			if out.Values[i] == graphql.Null {
12453				invalids++
12454			}
12455		case "nodes":
12456			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12457			if out.Values[i] == graphql.Null {
12458				invalids++
12459			}
12460		case "pageInfo":
12461			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12462			if out.Values[i] == graphql.Null {
12463				invalids++
12464			}
12465		case "totalCount":
12466			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12467			if out.Values[i] == graphql.Null {
12468				invalids++
12469			}
12470		default:
12471			panic("unknown field " + strconv.Quote(field.Name))
12472		}
12473	}
12474	out.Dispatch()
12475	if invalids > 0 {
12476		return graphql.Null
12477	}
12478	return out
12479}
12480
12481var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12482
12483func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12484	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12485
12486	out := graphql.NewFieldSet(fields)
12487	var invalids uint32
12488	for i, field := range fields {
12489		switch field.Name {
12490		case "__typename":
12491			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12492		case "cursor":
12493			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12494			if out.Values[i] == graphql.Null {
12495				invalids++
12496			}
12497		case "node":
12498			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12499			if out.Values[i] == graphql.Null {
12500				invalids++
12501			}
12502		default:
12503			panic("unknown field " + strconv.Quote(field.Name))
12504		}
12505	}
12506	out.Dispatch()
12507	if invalids > 0 {
12508		return graphql.Null
12509	}
12510	return out
12511}
12512
12513var __DirectiveImplementors = []string{"__Directive"}
12514
12515func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12516	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12517
12518	out := graphql.NewFieldSet(fields)
12519	var invalids uint32
12520	for i, field := range fields {
12521		switch field.Name {
12522		case "__typename":
12523			out.Values[i] = graphql.MarshalString("__Directive")
12524		case "name":
12525			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12526			if out.Values[i] == graphql.Null {
12527				invalids++
12528			}
12529		case "description":
12530			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12531		case "locations":
12532			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12533			if out.Values[i] == graphql.Null {
12534				invalids++
12535			}
12536		case "args":
12537			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12538			if out.Values[i] == graphql.Null {
12539				invalids++
12540			}
12541		default:
12542			panic("unknown field " + strconv.Quote(field.Name))
12543		}
12544	}
12545	out.Dispatch()
12546	if invalids > 0 {
12547		return graphql.Null
12548	}
12549	return out
12550}
12551
12552var __EnumValueImplementors = []string{"__EnumValue"}
12553
12554func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12555	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
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("__EnumValue")
12563		case "name":
12564			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12565			if out.Values[i] == graphql.Null {
12566				invalids++
12567			}
12568		case "description":
12569			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12570		case "isDeprecated":
12571			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12572			if out.Values[i] == graphql.Null {
12573				invalids++
12574			}
12575		case "deprecationReason":
12576			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12577		default:
12578			panic("unknown field " + strconv.Quote(field.Name))
12579		}
12580	}
12581	out.Dispatch()
12582	if invalids > 0 {
12583		return graphql.Null
12584	}
12585	return out
12586}
12587
12588var __FieldImplementors = []string{"__Field"}
12589
12590func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12591	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
12592
12593	out := graphql.NewFieldSet(fields)
12594	var invalids uint32
12595	for i, field := range fields {
12596		switch field.Name {
12597		case "__typename":
12598			out.Values[i] = graphql.MarshalString("__Field")
12599		case "name":
12600			out.Values[i] = ec.___Field_name(ctx, field, obj)
12601			if out.Values[i] == graphql.Null {
12602				invalids++
12603			}
12604		case "description":
12605			out.Values[i] = ec.___Field_description(ctx, field, obj)
12606		case "args":
12607			out.Values[i] = ec.___Field_args(ctx, field, obj)
12608			if out.Values[i] == graphql.Null {
12609				invalids++
12610			}
12611		case "type":
12612			out.Values[i] = ec.___Field_type(ctx, field, obj)
12613			if out.Values[i] == graphql.Null {
12614				invalids++
12615			}
12616		case "isDeprecated":
12617			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
12618			if out.Values[i] == graphql.Null {
12619				invalids++
12620			}
12621		case "deprecationReason":
12622			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
12623		default:
12624			panic("unknown field " + strconv.Quote(field.Name))
12625		}
12626	}
12627	out.Dispatch()
12628	if invalids > 0 {
12629		return graphql.Null
12630	}
12631	return out
12632}
12633
12634var __InputValueImplementors = []string{"__InputValue"}
12635
12636func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
12637	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
12638
12639	out := graphql.NewFieldSet(fields)
12640	var invalids uint32
12641	for i, field := range fields {
12642		switch field.Name {
12643		case "__typename":
12644			out.Values[i] = graphql.MarshalString("__InputValue")
12645		case "name":
12646			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
12647			if out.Values[i] == graphql.Null {
12648				invalids++
12649			}
12650		case "description":
12651			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
12652		case "type":
12653			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
12654			if out.Values[i] == graphql.Null {
12655				invalids++
12656			}
12657		case "defaultValue":
12658			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
12659		default:
12660			panic("unknown field " + strconv.Quote(field.Name))
12661		}
12662	}
12663	out.Dispatch()
12664	if invalids > 0 {
12665		return graphql.Null
12666	}
12667	return out
12668}
12669
12670var __SchemaImplementors = []string{"__Schema"}
12671
12672func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
12673	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
12674
12675	out := graphql.NewFieldSet(fields)
12676	var invalids uint32
12677	for i, field := range fields {
12678		switch field.Name {
12679		case "__typename":
12680			out.Values[i] = graphql.MarshalString("__Schema")
12681		case "types":
12682			out.Values[i] = ec.___Schema_types(ctx, field, obj)
12683			if out.Values[i] == graphql.Null {
12684				invalids++
12685			}
12686		case "queryType":
12687			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
12688			if out.Values[i] == graphql.Null {
12689				invalids++
12690			}
12691		case "mutationType":
12692			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
12693		case "subscriptionType":
12694			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
12695		case "directives":
12696			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
12697			if out.Values[i] == graphql.Null {
12698				invalids++
12699			}
12700		default:
12701			panic("unknown field " + strconv.Quote(field.Name))
12702		}
12703	}
12704	out.Dispatch()
12705	if invalids > 0 {
12706		return graphql.Null
12707	}
12708	return out
12709}
12710
12711var __TypeImplementors = []string{"__Type"}
12712
12713func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
12714	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
12715
12716	out := graphql.NewFieldSet(fields)
12717	var invalids uint32
12718	for i, field := range fields {
12719		switch field.Name {
12720		case "__typename":
12721			out.Values[i] = graphql.MarshalString("__Type")
12722		case "kind":
12723			out.Values[i] = ec.___Type_kind(ctx, field, obj)
12724			if out.Values[i] == graphql.Null {
12725				invalids++
12726			}
12727		case "name":
12728			out.Values[i] = ec.___Type_name(ctx, field, obj)
12729		case "description":
12730			out.Values[i] = ec.___Type_description(ctx, field, obj)
12731		case "fields":
12732			out.Values[i] = ec.___Type_fields(ctx, field, obj)
12733		case "interfaces":
12734			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
12735		case "possibleTypes":
12736			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
12737		case "enumValues":
12738			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
12739		case "inputFields":
12740			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
12741		case "ofType":
12742			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
12743		default:
12744			panic("unknown field " + strconv.Quote(field.Name))
12745		}
12746	}
12747	out.Dispatch()
12748	if invalids > 0 {
12749		return graphql.Null
12750	}
12751	return out
12752}
12753
12754// endregion **************************** object.gotpl ****************************
12755
12756// region    ***************************** type.gotpl *****************************
12757
12758func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
12759	return ec.unmarshalInputAddCommentInput(ctx, v)
12760}
12761
12762func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
12763	return ec._AddCommentOperation(ctx, sel, &v)
12764}
12765
12766func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
12767	if v == nil {
12768		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12769			ec.Errorf(ctx, "must not be null")
12770		}
12771		return graphql.Null
12772	}
12773	return ec._AddCommentOperation(ctx, sel, v)
12774}
12775
12776func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
12777	return ec._AddCommentPayload(ctx, sel, &v)
12778}
12779
12780func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
12781	if v == nil {
12782		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12783			ec.Errorf(ctx, "must not be null")
12784		}
12785		return graphql.Null
12786	}
12787	return ec._AddCommentPayload(ctx, sel, v)
12788}
12789
12790func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
12791	return graphql.UnmarshalBoolean(v)
12792}
12793
12794func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
12795	res := graphql.MarshalBoolean(v)
12796	if res == graphql.Null {
12797		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12798			ec.Errorf(ctx, "must not be null")
12799		}
12800	}
12801	return res
12802}
12803
12804func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
12805	if v == nil {
12806		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12807			ec.Errorf(ctx, "must not be null")
12808		}
12809		return graphql.Null
12810	}
12811	return ec._Bug(ctx, sel, v)
12812}
12813
12814func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
12815	ret := make(graphql.Array, len(v))
12816	var wg sync.WaitGroup
12817	isLen1 := len(v) == 1
12818	if !isLen1 {
12819		wg.Add(len(v))
12820	}
12821	for i := range v {
12822		i := i
12823		fc := &graphql.FieldContext{
12824			Index:  &i,
12825			Result: &v[i],
12826		}
12827		ctx := graphql.WithFieldContext(ctx, fc)
12828		f := func(i int) {
12829			defer func() {
12830				if r := recover(); r != nil {
12831					ec.Error(ctx, ec.Recover(ctx, r))
12832					ret = nil
12833				}
12834			}()
12835			if !isLen1 {
12836				defer wg.Done()
12837			}
12838			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
12839		}
12840		if isLen1 {
12841			f(i)
12842		} else {
12843			go f(i)
12844		}
12845
12846	}
12847	wg.Wait()
12848	return ret
12849}
12850
12851func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
12852	return ec._BugConnection(ctx, sel, &v)
12853}
12854
12855func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
12856	if v == nil {
12857		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12858			ec.Errorf(ctx, "must not be null")
12859		}
12860		return graphql.Null
12861	}
12862	return ec._BugConnection(ctx, sel, v)
12863}
12864
12865func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
12866	return ec._BugEdge(ctx, sel, &v)
12867}
12868
12869func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
12870	ret := make(graphql.Array, len(v))
12871	var wg sync.WaitGroup
12872	isLen1 := len(v) == 1
12873	if !isLen1 {
12874		wg.Add(len(v))
12875	}
12876	for i := range v {
12877		i := i
12878		fc := &graphql.FieldContext{
12879			Index:  &i,
12880			Result: &v[i],
12881		}
12882		ctx := graphql.WithFieldContext(ctx, fc)
12883		f := func(i int) {
12884			defer func() {
12885				if r := recover(); r != nil {
12886					ec.Error(ctx, ec.Recover(ctx, r))
12887					ret = nil
12888				}
12889			}()
12890			if !isLen1 {
12891				defer wg.Done()
12892			}
12893			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
12894		}
12895		if isLen1 {
12896			f(i)
12897		} else {
12898			go f(i)
12899		}
12900
12901	}
12902	wg.Wait()
12903	return ret
12904}
12905
12906func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
12907	if v == nil {
12908		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12909			ec.Errorf(ctx, "must not be null")
12910		}
12911		return graphql.Null
12912	}
12913	return ec._BugEdge(ctx, sel, v)
12914}
12915
12916func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
12917	return ec._ChangeLabelPayload(ctx, sel, &v)
12918}
12919
12920func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
12921	if v == nil {
12922		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12923			ec.Errorf(ctx, "must not be null")
12924		}
12925		return graphql.Null
12926	}
12927	return ec._ChangeLabelPayload(ctx, sel, v)
12928}
12929
12930func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
12931	return ec.unmarshalInputCloseBugInput(ctx, v)
12932}
12933
12934func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
12935	return ec._CloseBugPayload(ctx, sel, &v)
12936}
12937
12938func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
12939	if v == nil {
12940		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12941			ec.Errorf(ctx, "must not be null")
12942		}
12943		return graphql.Null
12944	}
12945	return ec._CloseBugPayload(ctx, sel, v)
12946}
12947
12948func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
12949	return ec._Color(ctx, sel, &v)
12950}
12951
12952func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
12953	if v == nil {
12954		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12955			ec.Errorf(ctx, "must not be null")
12956		}
12957		return graphql.Null
12958	}
12959	return ec._Color(ctx, sel, v)
12960}
12961
12962func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
12963	return ec._Comment(ctx, sel, &v)
12964}
12965
12966func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
12967	ret := make(graphql.Array, len(v))
12968	var wg sync.WaitGroup
12969	isLen1 := len(v) == 1
12970	if !isLen1 {
12971		wg.Add(len(v))
12972	}
12973	for i := range v {
12974		i := i
12975		fc := &graphql.FieldContext{
12976			Index:  &i,
12977			Result: &v[i],
12978		}
12979		ctx := graphql.WithFieldContext(ctx, fc)
12980		f := func(i int) {
12981			defer func() {
12982				if r := recover(); r != nil {
12983					ec.Error(ctx, ec.Recover(ctx, r))
12984					ret = nil
12985				}
12986			}()
12987			if !isLen1 {
12988				defer wg.Done()
12989			}
12990			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
12991		}
12992		if isLen1 {
12993			f(i)
12994		} else {
12995			go f(i)
12996		}
12997
12998	}
12999	wg.Wait()
13000	return ret
13001}
13002
13003func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13004	if v == nil {
13005		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13006			ec.Errorf(ctx, "must not be null")
13007		}
13008		return graphql.Null
13009	}
13010	return ec._Comment(ctx, sel, v)
13011}
13012
13013func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13014	return ec._CommentConnection(ctx, sel, &v)
13015}
13016
13017func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13018	if v == nil {
13019		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13020			ec.Errorf(ctx, "must not be null")
13021		}
13022		return graphql.Null
13023	}
13024	return ec._CommentConnection(ctx, sel, v)
13025}
13026
13027func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13028	return ec._CommentEdge(ctx, sel, &v)
13029}
13030
13031func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13032	ret := make(graphql.Array, len(v))
13033	var wg sync.WaitGroup
13034	isLen1 := len(v) == 1
13035	if !isLen1 {
13036		wg.Add(len(v))
13037	}
13038	for i := range v {
13039		i := i
13040		fc := &graphql.FieldContext{
13041			Index:  &i,
13042			Result: &v[i],
13043		}
13044		ctx := graphql.WithFieldContext(ctx, fc)
13045		f := func(i int) {
13046			defer func() {
13047				if r := recover(); r != nil {
13048					ec.Error(ctx, ec.Recover(ctx, r))
13049					ret = nil
13050				}
13051			}()
13052			if !isLen1 {
13053				defer wg.Done()
13054			}
13055			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13056		}
13057		if isLen1 {
13058			f(i)
13059		} else {
13060			go f(i)
13061		}
13062
13063	}
13064	wg.Wait()
13065	return ret
13066}
13067
13068func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13069	if v == nil {
13070		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13071			ec.Errorf(ctx, "must not be null")
13072		}
13073		return graphql.Null
13074	}
13075	return ec._CommentEdge(ctx, sel, v)
13076}
13077
13078func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13079	return ec._CommentHistoryStep(ctx, sel, &v)
13080}
13081
13082func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13083	ret := make(graphql.Array, len(v))
13084	var wg sync.WaitGroup
13085	isLen1 := len(v) == 1
13086	if !isLen1 {
13087		wg.Add(len(v))
13088	}
13089	for i := range v {
13090		i := i
13091		fc := &graphql.FieldContext{
13092			Index:  &i,
13093			Result: &v[i],
13094		}
13095		ctx := graphql.WithFieldContext(ctx, fc)
13096		f := func(i int) {
13097			defer func() {
13098				if r := recover(); r != nil {
13099					ec.Error(ctx, ec.Recover(ctx, r))
13100					ret = nil
13101				}
13102			}()
13103			if !isLen1 {
13104				defer wg.Done()
13105			}
13106			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13107		}
13108		if isLen1 {
13109			f(i)
13110		} else {
13111			go f(i)
13112		}
13113
13114	}
13115	wg.Wait()
13116	return ret
13117}
13118
13119func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13120	return ec._CreateOperation(ctx, sel, &v)
13121}
13122
13123func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13124	if v == nil {
13125		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13126			ec.Errorf(ctx, "must not be null")
13127		}
13128		return graphql.Null
13129	}
13130	return ec._CreateOperation(ctx, sel, v)
13131}
13132
13133func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13134	var res git.Hash
13135	return res, res.UnmarshalGQL(v)
13136}
13137
13138func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13139	return v
13140}
13141
13142func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13143	var vSlice []interface{}
13144	if v != nil {
13145		if tmp1, ok := v.([]interface{}); ok {
13146			vSlice = tmp1
13147		} else {
13148			vSlice = []interface{}{v}
13149		}
13150	}
13151	var err error
13152	res := make([]git.Hash, len(vSlice))
13153	for i := range vSlice {
13154		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13155		if err != nil {
13156			return nil, err
13157		}
13158	}
13159	return res, nil
13160}
13161
13162func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13163	ret := make(graphql.Array, len(v))
13164	for i := range v {
13165		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13166	}
13167
13168	return ret
13169}
13170
13171func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13172	if v == nil {
13173		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13174			ec.Errorf(ctx, "must not be null")
13175		}
13176		return graphql.Null
13177	}
13178	return ec._Identity(ctx, sel, v)
13179}
13180
13181func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13182	ret := make(graphql.Array, len(v))
13183	var wg sync.WaitGroup
13184	isLen1 := len(v) == 1
13185	if !isLen1 {
13186		wg.Add(len(v))
13187	}
13188	for i := range v {
13189		i := i
13190		fc := &graphql.FieldContext{
13191			Index:  &i,
13192			Result: &v[i],
13193		}
13194		ctx := graphql.WithFieldContext(ctx, fc)
13195		f := func(i int) {
13196			defer func() {
13197				if r := recover(); r != nil {
13198					ec.Error(ctx, ec.Recover(ctx, r))
13199					ret = nil
13200				}
13201			}()
13202			if !isLen1 {
13203				defer wg.Done()
13204			}
13205			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13206		}
13207		if isLen1 {
13208			f(i)
13209		} else {
13210			go f(i)
13211		}
13212
13213	}
13214	wg.Wait()
13215	return ret
13216}
13217
13218func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13219	return ec._IdentityConnection(ctx, sel, &v)
13220}
13221
13222func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13223	if v == nil {
13224		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13225			ec.Errorf(ctx, "must not be null")
13226		}
13227		return graphql.Null
13228	}
13229	return ec._IdentityConnection(ctx, sel, v)
13230}
13231
13232func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13233	return ec._IdentityEdge(ctx, sel, &v)
13234}
13235
13236func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13237	ret := make(graphql.Array, len(v))
13238	var wg sync.WaitGroup
13239	isLen1 := len(v) == 1
13240	if !isLen1 {
13241		wg.Add(len(v))
13242	}
13243	for i := range v {
13244		i := i
13245		fc := &graphql.FieldContext{
13246			Index:  &i,
13247			Result: &v[i],
13248		}
13249		ctx := graphql.WithFieldContext(ctx, fc)
13250		f := func(i int) {
13251			defer func() {
13252				if r := recover(); r != nil {
13253					ec.Error(ctx, ec.Recover(ctx, r))
13254					ret = nil
13255				}
13256			}()
13257			if !isLen1 {
13258				defer wg.Done()
13259			}
13260			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13261		}
13262		if isLen1 {
13263			f(i)
13264		} else {
13265			go f(i)
13266		}
13267
13268	}
13269	wg.Wait()
13270	return ret
13271}
13272
13273func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13274	if v == nil {
13275		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13276			ec.Errorf(ctx, "must not be null")
13277		}
13278		return graphql.Null
13279	}
13280	return ec._IdentityEdge(ctx, sel, v)
13281}
13282
13283func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13284	return graphql.UnmarshalInt(v)
13285}
13286
13287func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13288	res := graphql.MarshalInt(v)
13289	if res == graphql.Null {
13290		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13291			ec.Errorf(ctx, "must not be null")
13292		}
13293	}
13294	return res
13295}
13296
13297func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13298	return ec._Label(ctx, sel, &v)
13299}
13300
13301func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13302	ret := make(graphql.Array, len(v))
13303	var wg sync.WaitGroup
13304	isLen1 := len(v) == 1
13305	if !isLen1 {
13306		wg.Add(len(v))
13307	}
13308	for i := range v {
13309		i := i
13310		fc := &graphql.FieldContext{
13311			Index:  &i,
13312			Result: &v[i],
13313		}
13314		ctx := graphql.WithFieldContext(ctx, fc)
13315		f := func(i int) {
13316			defer func() {
13317				if r := recover(); r != nil {
13318					ec.Error(ctx, ec.Recover(ctx, r))
13319					ret = nil
13320				}
13321			}()
13322			if !isLen1 {
13323				defer wg.Done()
13324			}
13325			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13326		}
13327		if isLen1 {
13328			f(i)
13329		} else {
13330			go f(i)
13331		}
13332
13333	}
13334	wg.Wait()
13335	return ret
13336}
13337
13338func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13339	return ec._LabelChangeOperation(ctx, sel, &v)
13340}
13341
13342func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13343	if v == nil {
13344		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13345			ec.Errorf(ctx, "must not be null")
13346		}
13347		return graphql.Null
13348	}
13349	return ec._LabelChangeOperation(ctx, sel, v)
13350}
13351
13352func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13353	ret := make(graphql.Array, len(v))
13354	var wg sync.WaitGroup
13355	isLen1 := len(v) == 1
13356	if !isLen1 {
13357		wg.Add(len(v))
13358	}
13359	for i := range v {
13360		i := i
13361		fc := &graphql.FieldContext{
13362			Index:  &i,
13363			Result: &v[i],
13364		}
13365		ctx := graphql.WithFieldContext(ctx, fc)
13366		f := func(i int) {
13367			defer func() {
13368				if r := recover(); r != nil {
13369					ec.Error(ctx, ec.Recover(ctx, r))
13370					ret = nil
13371				}
13372			}()
13373			if !isLen1 {
13374				defer wg.Done()
13375			}
13376			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13377		}
13378		if isLen1 {
13379			f(i)
13380		} else {
13381			go f(i)
13382		}
13383
13384	}
13385	wg.Wait()
13386	return ret
13387}
13388
13389func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13390	var res models.LabelChangeStatus
13391	return res, res.UnmarshalGQL(v)
13392}
13393
13394func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13395	return v
13396}
13397
13398func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13399	return ec._LabelConnection(ctx, sel, &v)
13400}
13401
13402func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13403	if v == nil {
13404		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13405			ec.Errorf(ctx, "must not be null")
13406		}
13407		return graphql.Null
13408	}
13409	return ec._LabelConnection(ctx, sel, v)
13410}
13411
13412func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13413	return ec._LabelEdge(ctx, sel, &v)
13414}
13415
13416func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13417	ret := make(graphql.Array, len(v))
13418	var wg sync.WaitGroup
13419	isLen1 := len(v) == 1
13420	if !isLen1 {
13421		wg.Add(len(v))
13422	}
13423	for i := range v {
13424		i := i
13425		fc := &graphql.FieldContext{
13426			Index:  &i,
13427			Result: &v[i],
13428		}
13429		ctx := graphql.WithFieldContext(ctx, fc)
13430		f := func(i int) {
13431			defer func() {
13432				if r := recover(); r != nil {
13433					ec.Error(ctx, ec.Recover(ctx, r))
13434					ret = nil
13435				}
13436			}()
13437			if !isLen1 {
13438				defer wg.Done()
13439			}
13440			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13441		}
13442		if isLen1 {
13443			f(i)
13444		} else {
13445			go f(i)
13446		}
13447
13448	}
13449	wg.Wait()
13450	return ret
13451}
13452
13453func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13454	if v == nil {
13455		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13456			ec.Errorf(ctx, "must not be null")
13457		}
13458		return graphql.Null
13459	}
13460	return ec._LabelEdge(ctx, sel, v)
13461}
13462
13463func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13464	return ec.unmarshalInputNewBugInput(ctx, v)
13465}
13466
13467func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13468	return ec._NewBugPayload(ctx, sel, &v)
13469}
13470
13471func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13472	if v == nil {
13473		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13474			ec.Errorf(ctx, "must not be null")
13475		}
13476		return graphql.Null
13477	}
13478	return ec._NewBugPayload(ctx, sel, v)
13479}
13480
13481func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13482	return ec.unmarshalInputOpenBugInput(ctx, v)
13483}
13484
13485func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13486	return ec._OpenBugPayload(ctx, sel, &v)
13487}
13488
13489func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13490	if v == nil {
13491		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13492			ec.Errorf(ctx, "must not be null")
13493		}
13494		return graphql.Null
13495	}
13496	return ec._OpenBugPayload(ctx, sel, v)
13497}
13498
13499func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13500	if v == nil {
13501		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13502			ec.Errorf(ctx, "must not be null")
13503		}
13504		return graphql.Null
13505	}
13506	return ec._Operation(ctx, sel, v)
13507}
13508
13509func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13510	ret := make(graphql.Array, len(v))
13511	var wg sync.WaitGroup
13512	isLen1 := len(v) == 1
13513	if !isLen1 {
13514		wg.Add(len(v))
13515	}
13516	for i := range v {
13517		i := i
13518		fc := &graphql.FieldContext{
13519			Index:  &i,
13520			Result: &v[i],
13521		}
13522		ctx := graphql.WithFieldContext(ctx, fc)
13523		f := func(i int) {
13524			defer func() {
13525				if r := recover(); r != nil {
13526					ec.Error(ctx, ec.Recover(ctx, r))
13527					ret = nil
13528				}
13529			}()
13530			if !isLen1 {
13531				defer wg.Done()
13532			}
13533			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13534		}
13535		if isLen1 {
13536			f(i)
13537		} else {
13538			go f(i)
13539		}
13540
13541	}
13542	wg.Wait()
13543	return ret
13544}
13545
13546func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13547	return ec._OperationConnection(ctx, sel, &v)
13548}
13549
13550func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13551	if v == nil {
13552		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13553			ec.Errorf(ctx, "must not be null")
13554		}
13555		return graphql.Null
13556	}
13557	return ec._OperationConnection(ctx, sel, v)
13558}
13559
13560func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13561	return ec._OperationEdge(ctx, sel, &v)
13562}
13563
13564func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13565	ret := make(graphql.Array, len(v))
13566	var wg sync.WaitGroup
13567	isLen1 := len(v) == 1
13568	if !isLen1 {
13569		wg.Add(len(v))
13570	}
13571	for i := range v {
13572		i := i
13573		fc := &graphql.FieldContext{
13574			Index:  &i,
13575			Result: &v[i],
13576		}
13577		ctx := graphql.WithFieldContext(ctx, fc)
13578		f := func(i int) {
13579			defer func() {
13580				if r := recover(); r != nil {
13581					ec.Error(ctx, ec.Recover(ctx, r))
13582					ret = nil
13583				}
13584			}()
13585			if !isLen1 {
13586				defer wg.Done()
13587			}
13588			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13589		}
13590		if isLen1 {
13591			f(i)
13592		} else {
13593			go f(i)
13594		}
13595
13596	}
13597	wg.Wait()
13598	return ret
13599}
13600
13601func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
13602	if v == nil {
13603		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13604			ec.Errorf(ctx, "must not be null")
13605		}
13606		return graphql.Null
13607	}
13608	return ec._OperationEdge(ctx, sel, v)
13609}
13610
13611func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
13612	return ec._PageInfo(ctx, sel, &v)
13613}
13614
13615func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
13616	if v == nil {
13617		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13618			ec.Errorf(ctx, "must not be null")
13619		}
13620		return graphql.Null
13621	}
13622	return ec._PageInfo(ctx, sel, v)
13623}
13624
13625func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
13626	return ec._SetStatusOperation(ctx, sel, &v)
13627}
13628
13629func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
13630	if v == nil {
13631		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13632			ec.Errorf(ctx, "must not be null")
13633		}
13634		return graphql.Null
13635	}
13636	return ec._SetStatusOperation(ctx, sel, v)
13637}
13638
13639func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
13640	return ec.unmarshalInputSetTitleInput(ctx, v)
13641}
13642
13643func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
13644	return ec._SetTitleOperation(ctx, sel, &v)
13645}
13646
13647func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
13648	if v == nil {
13649		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13650			ec.Errorf(ctx, "must not be null")
13651		}
13652		return graphql.Null
13653	}
13654	return ec._SetTitleOperation(ctx, sel, v)
13655}
13656
13657func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
13658	return ec._SetTitlePayload(ctx, sel, &v)
13659}
13660
13661func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
13662	if v == nil {
13663		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13664			ec.Errorf(ctx, "must not be null")
13665		}
13666		return graphql.Null
13667	}
13668	return ec._SetTitlePayload(ctx, sel, v)
13669}
13670
13671func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
13672	var res models.Status
13673	return res, res.UnmarshalGQL(v)
13674}
13675
13676func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
13677	return v
13678}
13679
13680func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
13681	return graphql.UnmarshalString(v)
13682}
13683
13684func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13685	res := graphql.MarshalString(v)
13686	if res == graphql.Null {
13687		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13688			ec.Errorf(ctx, "must not be null")
13689		}
13690	}
13691	return res
13692}
13693
13694func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
13695	return graphql.UnmarshalTime(v)
13696}
13697
13698func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
13699	res := graphql.MarshalTime(v)
13700	if res == graphql.Null {
13701		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13702			ec.Errorf(ctx, "must not be null")
13703		}
13704	}
13705	return res
13706}
13707
13708func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
13709	if v == nil {
13710		return nil, nil
13711	}
13712	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
13713	return &res, err
13714}
13715
13716func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
13717	if v == nil {
13718		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13719			ec.Errorf(ctx, "must not be null")
13720		}
13721		return graphql.Null
13722	}
13723	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
13724}
13725
13726func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
13727	if v == nil {
13728		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13729			ec.Errorf(ctx, "must not be null")
13730		}
13731		return graphql.Null
13732	}
13733	return ec._TimelineItem(ctx, sel, v)
13734}
13735
13736func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
13737	ret := make(graphql.Array, len(v))
13738	var wg sync.WaitGroup
13739	isLen1 := len(v) == 1
13740	if !isLen1 {
13741		wg.Add(len(v))
13742	}
13743	for i := range v {
13744		i := i
13745		fc := &graphql.FieldContext{
13746			Index:  &i,
13747			Result: &v[i],
13748		}
13749		ctx := graphql.WithFieldContext(ctx, fc)
13750		f := func(i int) {
13751			defer func() {
13752				if r := recover(); r != nil {
13753					ec.Error(ctx, ec.Recover(ctx, r))
13754					ret = nil
13755				}
13756			}()
13757			if !isLen1 {
13758				defer wg.Done()
13759			}
13760			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
13761		}
13762		if isLen1 {
13763			f(i)
13764		} else {
13765			go f(i)
13766		}
13767
13768	}
13769	wg.Wait()
13770	return ret
13771}
13772
13773func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
13774	return ec._TimelineItemConnection(ctx, sel, &v)
13775}
13776
13777func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
13778	if v == nil {
13779		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13780			ec.Errorf(ctx, "must not be null")
13781		}
13782		return graphql.Null
13783	}
13784	return ec._TimelineItemConnection(ctx, sel, v)
13785}
13786
13787func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
13788	return ec._TimelineItemEdge(ctx, sel, &v)
13789}
13790
13791func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
13792	ret := make(graphql.Array, len(v))
13793	var wg sync.WaitGroup
13794	isLen1 := len(v) == 1
13795	if !isLen1 {
13796		wg.Add(len(v))
13797	}
13798	for i := range v {
13799		i := i
13800		fc := &graphql.FieldContext{
13801			Index:  &i,
13802			Result: &v[i],
13803		}
13804		ctx := graphql.WithFieldContext(ctx, fc)
13805		f := func(i int) {
13806			defer func() {
13807				if r := recover(); r != nil {
13808					ec.Error(ctx, ec.Recover(ctx, r))
13809					ret = nil
13810				}
13811			}()
13812			if !isLen1 {
13813				defer wg.Done()
13814			}
13815			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
13816		}
13817		if isLen1 {
13818			f(i)
13819		} else {
13820			go f(i)
13821		}
13822
13823	}
13824	wg.Wait()
13825	return ret
13826}
13827
13828func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
13829	if v == nil {
13830		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13831			ec.Errorf(ctx, "must not be null")
13832		}
13833		return graphql.Null
13834	}
13835	return ec._TimelineItemEdge(ctx, sel, v)
13836}
13837
13838func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
13839	return ec.___Directive(ctx, sel, &v)
13840}
13841
13842func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
13843	ret := make(graphql.Array, len(v))
13844	var wg sync.WaitGroup
13845	isLen1 := len(v) == 1
13846	if !isLen1 {
13847		wg.Add(len(v))
13848	}
13849	for i := range v {
13850		i := i
13851		fc := &graphql.FieldContext{
13852			Index:  &i,
13853			Result: &v[i],
13854		}
13855		ctx := graphql.WithFieldContext(ctx, fc)
13856		f := func(i int) {
13857			defer func() {
13858				if r := recover(); r != nil {
13859					ec.Error(ctx, ec.Recover(ctx, r))
13860					ret = nil
13861				}
13862			}()
13863			if !isLen1 {
13864				defer wg.Done()
13865			}
13866			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
13867		}
13868		if isLen1 {
13869			f(i)
13870		} else {
13871			go f(i)
13872		}
13873
13874	}
13875	wg.Wait()
13876	return ret
13877}
13878
13879func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
13880	return graphql.UnmarshalString(v)
13881}
13882
13883func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13884	res := graphql.MarshalString(v)
13885	if res == graphql.Null {
13886		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13887			ec.Errorf(ctx, "must not be null")
13888		}
13889	}
13890	return res
13891}
13892
13893func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
13894	var vSlice []interface{}
13895	if v != nil {
13896		if tmp1, ok := v.([]interface{}); ok {
13897			vSlice = tmp1
13898		} else {
13899			vSlice = []interface{}{v}
13900		}
13901	}
13902	var err error
13903	res := make([]string, len(vSlice))
13904	for i := range vSlice {
13905		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
13906		if err != nil {
13907			return nil, err
13908		}
13909	}
13910	return res, nil
13911}
13912
13913func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
13914	ret := make(graphql.Array, len(v))
13915	var wg sync.WaitGroup
13916	isLen1 := len(v) == 1
13917	if !isLen1 {
13918		wg.Add(len(v))
13919	}
13920	for i := range v {
13921		i := i
13922		fc := &graphql.FieldContext{
13923			Index:  &i,
13924			Result: &v[i],
13925		}
13926		ctx := graphql.WithFieldContext(ctx, fc)
13927		f := func(i int) {
13928			defer func() {
13929				if r := recover(); r != nil {
13930					ec.Error(ctx, ec.Recover(ctx, r))
13931					ret = nil
13932				}
13933			}()
13934			if !isLen1 {
13935				defer wg.Done()
13936			}
13937			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
13938		}
13939		if isLen1 {
13940			f(i)
13941		} else {
13942			go f(i)
13943		}
13944
13945	}
13946	wg.Wait()
13947	return ret
13948}
13949
13950func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
13951	return ec.___EnumValue(ctx, sel, &v)
13952}
13953
13954func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
13955	return ec.___Field(ctx, sel, &v)
13956}
13957
13958func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
13959	return ec.___InputValue(ctx, sel, &v)
13960}
13961
13962func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
13963	ret := make(graphql.Array, len(v))
13964	var wg sync.WaitGroup
13965	isLen1 := len(v) == 1
13966	if !isLen1 {
13967		wg.Add(len(v))
13968	}
13969	for i := range v {
13970		i := i
13971		fc := &graphql.FieldContext{
13972			Index:  &i,
13973			Result: &v[i],
13974		}
13975		ctx := graphql.WithFieldContext(ctx, fc)
13976		f := func(i int) {
13977			defer func() {
13978				if r := recover(); r != nil {
13979					ec.Error(ctx, ec.Recover(ctx, r))
13980					ret = nil
13981				}
13982			}()
13983			if !isLen1 {
13984				defer wg.Done()
13985			}
13986			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
13987		}
13988		if isLen1 {
13989			f(i)
13990		} else {
13991			go f(i)
13992		}
13993
13994	}
13995	wg.Wait()
13996	return ret
13997}
13998
13999func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14000	return ec.___Type(ctx, sel, &v)
14001}
14002
14003func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14004	ret := make(graphql.Array, len(v))
14005	var wg sync.WaitGroup
14006	isLen1 := len(v) == 1
14007	if !isLen1 {
14008		wg.Add(len(v))
14009	}
14010	for i := range v {
14011		i := i
14012		fc := &graphql.FieldContext{
14013			Index:  &i,
14014			Result: &v[i],
14015		}
14016		ctx := graphql.WithFieldContext(ctx, fc)
14017		f := func(i int) {
14018			defer func() {
14019				if r := recover(); r != nil {
14020					ec.Error(ctx, ec.Recover(ctx, r))
14021					ret = nil
14022				}
14023			}()
14024			if !isLen1 {
14025				defer wg.Done()
14026			}
14027			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14028		}
14029		if isLen1 {
14030			f(i)
14031		} else {
14032			go f(i)
14033		}
14034
14035	}
14036	wg.Wait()
14037	return ret
14038}
14039
14040func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14041	if v == nil {
14042		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14043			ec.Errorf(ctx, "must not be null")
14044		}
14045		return graphql.Null
14046	}
14047	return ec.___Type(ctx, sel, v)
14048}
14049
14050func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14051	return graphql.UnmarshalString(v)
14052}
14053
14054func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14055	res := graphql.MarshalString(v)
14056	if res == graphql.Null {
14057		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14058			ec.Errorf(ctx, "must not be null")
14059		}
14060	}
14061	return res
14062}
14063
14064func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14065	return graphql.UnmarshalBoolean(v)
14066}
14067
14068func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14069	return graphql.MarshalBoolean(v)
14070}
14071
14072func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14073	if v == nil {
14074		return nil, nil
14075	}
14076	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14077	return &res, err
14078}
14079
14080func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14081	if v == nil {
14082		return graphql.Null
14083	}
14084	return ec.marshalOBoolean2bool(ctx, sel, *v)
14085}
14086
14087func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14088	if v == nil {
14089		return graphql.Null
14090	}
14091	return ec._Bug(ctx, sel, v)
14092}
14093
14094func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14095	return ec.unmarshalInputChangeLabelInput(ctx, v)
14096}
14097
14098func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14099	if v == nil {
14100		return nil, nil
14101	}
14102	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14103	return &res, err
14104}
14105
14106func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14107	var vSlice []interface{}
14108	if v != nil {
14109		if tmp1, ok := v.([]interface{}); ok {
14110			vSlice = tmp1
14111		} else {
14112			vSlice = []interface{}{v}
14113		}
14114	}
14115	var err error
14116	res := make([]git.Hash, len(vSlice))
14117	for i := range vSlice {
14118		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14119		if err != nil {
14120			return nil, err
14121		}
14122	}
14123	return res, nil
14124}
14125
14126func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14127	if v == nil {
14128		return graphql.Null
14129	}
14130	ret := make(graphql.Array, len(v))
14131	for i := range v {
14132		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14133	}
14134
14135	return ret
14136}
14137
14138func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14139	if v == nil {
14140		return graphql.Null
14141	}
14142	return ec._Identity(ctx, sel, v)
14143}
14144
14145func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14146	return graphql.UnmarshalInt(v)
14147}
14148
14149func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14150	return graphql.MarshalInt(v)
14151}
14152
14153func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14154	if v == nil {
14155		return nil, nil
14156	}
14157	res, err := ec.unmarshalOInt2int(ctx, v)
14158	return &res, err
14159}
14160
14161func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14162	if v == nil {
14163		return graphql.Null
14164	}
14165	return ec.marshalOInt2int(ctx, sel, *v)
14166}
14167
14168func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14169	return ec._LabelChangeResult(ctx, sel, &v)
14170}
14171
14172func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14173	if v == nil {
14174		return graphql.Null
14175	}
14176	return ec._LabelChangeResult(ctx, sel, v)
14177}
14178
14179func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14180	return ec._Repository(ctx, sel, &v)
14181}
14182
14183func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14184	if v == nil {
14185		return graphql.Null
14186	}
14187	return ec._Repository(ctx, sel, v)
14188}
14189
14190func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14191	return graphql.UnmarshalString(v)
14192}
14193
14194func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14195	return graphql.MarshalString(v)
14196}
14197
14198func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14199	var vSlice []interface{}
14200	if v != nil {
14201		if tmp1, ok := v.([]interface{}); ok {
14202			vSlice = tmp1
14203		} else {
14204			vSlice = []interface{}{v}
14205		}
14206	}
14207	var err error
14208	res := make([]string, len(vSlice))
14209	for i := range vSlice {
14210		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14211		if err != nil {
14212			return nil, err
14213		}
14214	}
14215	return res, nil
14216}
14217
14218func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14219	if v == nil {
14220		return graphql.Null
14221	}
14222	ret := make(graphql.Array, len(v))
14223	for i := range v {
14224		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14225	}
14226
14227	return ret
14228}
14229
14230func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14231	if v == nil {
14232		return nil, nil
14233	}
14234	res, err := ec.unmarshalOString2string(ctx, v)
14235	return &res, err
14236}
14237
14238func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14239	if v == nil {
14240		return graphql.Null
14241	}
14242	return ec.marshalOString2string(ctx, sel, *v)
14243}
14244
14245func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14246	if v == nil {
14247		return graphql.Null
14248	}
14249	ret := make(graphql.Array, len(v))
14250	var wg sync.WaitGroup
14251	isLen1 := len(v) == 1
14252	if !isLen1 {
14253		wg.Add(len(v))
14254	}
14255	for i := range v {
14256		i := i
14257		fc := &graphql.FieldContext{
14258			Index:  &i,
14259			Result: &v[i],
14260		}
14261		ctx := graphql.WithFieldContext(ctx, fc)
14262		f := func(i int) {
14263			defer func() {
14264				if r := recover(); r != nil {
14265					ec.Error(ctx, ec.Recover(ctx, r))
14266					ret = nil
14267				}
14268			}()
14269			if !isLen1 {
14270				defer wg.Done()
14271			}
14272			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14273		}
14274		if isLen1 {
14275			f(i)
14276		} else {
14277			go f(i)
14278		}
14279
14280	}
14281	wg.Wait()
14282	return ret
14283}
14284
14285func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14286	if v == nil {
14287		return graphql.Null
14288	}
14289	ret := make(graphql.Array, len(v))
14290	var wg sync.WaitGroup
14291	isLen1 := len(v) == 1
14292	if !isLen1 {
14293		wg.Add(len(v))
14294	}
14295	for i := range v {
14296		i := i
14297		fc := &graphql.FieldContext{
14298			Index:  &i,
14299			Result: &v[i],
14300		}
14301		ctx := graphql.WithFieldContext(ctx, fc)
14302		f := func(i int) {
14303			defer func() {
14304				if r := recover(); r != nil {
14305					ec.Error(ctx, ec.Recover(ctx, r))
14306					ret = nil
14307				}
14308			}()
14309			if !isLen1 {
14310				defer wg.Done()
14311			}
14312			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14313		}
14314		if isLen1 {
14315			f(i)
14316		} else {
14317			go f(i)
14318		}
14319
14320	}
14321	wg.Wait()
14322	return ret
14323}
14324
14325func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14326	if v == nil {
14327		return graphql.Null
14328	}
14329	ret := make(graphql.Array, len(v))
14330	var wg sync.WaitGroup
14331	isLen1 := len(v) == 1
14332	if !isLen1 {
14333		wg.Add(len(v))
14334	}
14335	for i := range v {
14336		i := i
14337		fc := &graphql.FieldContext{
14338			Index:  &i,
14339			Result: &v[i],
14340		}
14341		ctx := graphql.WithFieldContext(ctx, fc)
14342		f := func(i int) {
14343			defer func() {
14344				if r := recover(); r != nil {
14345					ec.Error(ctx, ec.Recover(ctx, r))
14346					ret = nil
14347				}
14348			}()
14349			if !isLen1 {
14350				defer wg.Done()
14351			}
14352			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14353		}
14354		if isLen1 {
14355			f(i)
14356		} else {
14357			go f(i)
14358		}
14359
14360	}
14361	wg.Wait()
14362	return ret
14363}
14364
14365func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14366	return ec.___Schema(ctx, sel, &v)
14367}
14368
14369func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14370	if v == nil {
14371		return graphql.Null
14372	}
14373	return ec.___Schema(ctx, sel, v)
14374}
14375
14376func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14377	return ec.___Type(ctx, sel, &v)
14378}
14379
14380func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14381	if v == nil {
14382		return graphql.Null
14383	}
14384	ret := make(graphql.Array, len(v))
14385	var wg sync.WaitGroup
14386	isLen1 := len(v) == 1
14387	if !isLen1 {
14388		wg.Add(len(v))
14389	}
14390	for i := range v {
14391		i := i
14392		fc := &graphql.FieldContext{
14393			Index:  &i,
14394			Result: &v[i],
14395		}
14396		ctx := graphql.WithFieldContext(ctx, fc)
14397		f := func(i int) {
14398			defer func() {
14399				if r := recover(); r != nil {
14400					ec.Error(ctx, ec.Recover(ctx, r))
14401					ret = nil
14402				}
14403			}()
14404			if !isLen1 {
14405				defer wg.Done()
14406			}
14407			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14408		}
14409		if isLen1 {
14410			f(i)
14411		} else {
14412			go f(i)
14413		}
14414
14415	}
14416	wg.Wait()
14417	return ret
14418}
14419
14420func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14421	if v == nil {
14422		return graphql.Null
14423	}
14424	return ec.___Type(ctx, sel, v)
14425}
14426
14427// endregion ***************************** type.gotpl *****************************