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/vektah/gqlparser"
   19	"github.com/vektah/gqlparser/ast"
   20
   21	"github.com/MichaelMure/git-bug/api/graphql/models"
   22	"github.com/MichaelMure/git-bug/bug"
   23	"github.com/MichaelMure/git-bug/util/git"
   24)
   25
   26// region    ************************** generated!.gotpl **************************
   27
   28// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
   29func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
   30	return &executableSchema{
   31		resolvers:  cfg.Resolvers,
   32		directives: cfg.Directives,
   33		complexity: cfg.Complexity,
   34	}
   35}
   36
   37type Config struct {
   38	Resolvers  ResolverRoot
   39	Directives DirectiveRoot
   40	Complexity ComplexityRoot
   41}
   42
   43type ResolverRoot interface {
   44	AddCommentOperation() AddCommentOperationResolver
   45	AddCommentTimelineItem() AddCommentTimelineItemResolver
   46	Bug() BugResolver
   47	Color() ColorResolver
   48	Comment() CommentResolver
   49	CommentHistoryStep() CommentHistoryStepResolver
   50	CreateOperation() CreateOperationResolver
   51	CreateTimelineItem() CreateTimelineItemResolver
   52	EditCommentOperation() EditCommentOperationResolver
   53	Identity() IdentityResolver
   54	Label() LabelResolver
   55	LabelChangeOperation() LabelChangeOperationResolver
   56	LabelChangeResult() LabelChangeResultResolver
   57	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
   58	Mutation() MutationResolver
   59	Query() QueryResolver
   60	Repository() RepositoryResolver
   61	SetStatusOperation() SetStatusOperationResolver
   62	SetStatusTimelineItem() SetStatusTimelineItemResolver
   63	SetTitleOperation() SetTitleOperationResolver
   64	SetTitleTimelineItem() SetTitleTimelineItemResolver
   65}
   66
   67type DirectiveRoot struct {
   68}
   69
   70type ComplexityRoot struct {
   71	AddCommentOperation struct {
   72		Author  func(childComplexity int) int
   73		Date    func(childComplexity int) int
   74		Files   func(childComplexity int) int
   75		ID      func(childComplexity int) int
   76		Message func(childComplexity int) int
   77	}
   78
   79	AddCommentPayload struct {
   80		Bug              func(childComplexity int) int
   81		ClientMutationID func(childComplexity int) int
   82		Operation        func(childComplexity int) int
   83	}
   84
   85	AddCommentTimelineItem struct {
   86		Author         func(childComplexity int) int
   87		CreatedAt      func(childComplexity int) int
   88		Edited         func(childComplexity int) int
   89		Files          func(childComplexity int) int
   90		History        func(childComplexity int) int
   91		ID             func(childComplexity int) int
   92		LastEdit       func(childComplexity int) int
   93		Message        func(childComplexity int) int
   94		MessageIsEmpty func(childComplexity int) int
   95	}
   96
   97	Bug struct {
   98		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
   99		Author       func(childComplexity int) int
  100		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
  101		CreatedAt    func(childComplexity int) int
  102		HumanID      func(childComplexity int) int
  103		ID           func(childComplexity int) int
  104		Labels       func(childComplexity int) int
  105		LastEdit     func(childComplexity int) int
  106		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
  107		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
  108		Status       func(childComplexity int) int
  109		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
  110		Title        func(childComplexity int) int
  111	}
  112
  113	BugConnection struct {
  114		Edges      func(childComplexity int) int
  115		Nodes      func(childComplexity int) int
  116		PageInfo   func(childComplexity int) int
  117		TotalCount func(childComplexity int) int
  118	}
  119
  120	BugEdge struct {
  121		Cursor func(childComplexity int) int
  122		Node   func(childComplexity int) int
  123	}
  124
  125	ChangeLabelPayload struct {
  126		Bug              func(childComplexity int) int
  127		ClientMutationID func(childComplexity int) int
  128		Operation        func(childComplexity int) int
  129		Results          func(childComplexity int) int
  130	}
  131
  132	CloseBugPayload struct {
  133		Bug              func(childComplexity int) int
  134		ClientMutationID func(childComplexity int) int
  135		Operation        func(childComplexity int) int
  136	}
  137
  138	Color struct {
  139		B func(childComplexity int) int
  140		G func(childComplexity int) int
  141		R func(childComplexity int) int
  142	}
  143
  144	Comment struct {
  145		Author  func(childComplexity int) int
  146		Files   func(childComplexity int) int
  147		Message func(childComplexity int) int
  148	}
  149
  150	CommentConnection struct {
  151		Edges      func(childComplexity int) int
  152		Nodes      func(childComplexity int) int
  153		PageInfo   func(childComplexity int) int
  154		TotalCount func(childComplexity int) int
  155	}
  156
  157	CommentEdge struct {
  158		Cursor func(childComplexity int) int
  159		Node   func(childComplexity int) int
  160	}
  161
  162	CommentHistoryStep struct {
  163		Date    func(childComplexity int) int
  164		Message func(childComplexity int) int
  165	}
  166
  167	CreateOperation struct {
  168		Author  func(childComplexity int) int
  169		Date    func(childComplexity int) int
  170		Files   func(childComplexity int) int
  171		ID      func(childComplexity int) int
  172		Message func(childComplexity int) int
  173		Title   func(childComplexity int) int
  174	}
  175
  176	CreateTimelineItem struct {
  177		Author         func(childComplexity int) int
  178		CreatedAt      func(childComplexity int) int
  179		Edited         func(childComplexity int) int
  180		Files          func(childComplexity int) int
  181		History        func(childComplexity int) int
  182		ID             func(childComplexity int) int
  183		LastEdit       func(childComplexity int) int
  184		Message        func(childComplexity int) int
  185		MessageIsEmpty func(childComplexity int) int
  186	}
  187
  188	EditCommentOperation struct {
  189		Author  func(childComplexity int) int
  190		Date    func(childComplexity int) int
  191		Files   func(childComplexity int) int
  192		ID      func(childComplexity int) int
  193		Message func(childComplexity int) int
  194		Target  func(childComplexity int) int
  195	}
  196
  197	Identity struct {
  198		AvatarUrl   func(childComplexity int) int
  199		DisplayName func(childComplexity int) int
  200		Email       func(childComplexity int) int
  201		HumanID     func(childComplexity int) int
  202		ID          func(childComplexity int) int
  203		IsProtected func(childComplexity int) int
  204		Login       func(childComplexity int) int
  205		Name        func(childComplexity int) int
  206	}
  207
  208	IdentityConnection struct {
  209		Edges      func(childComplexity int) int
  210		Nodes      func(childComplexity int) int
  211		PageInfo   func(childComplexity int) int
  212		TotalCount func(childComplexity int) int
  213	}
  214
  215	IdentityEdge struct {
  216		Cursor func(childComplexity int) int
  217		Node   func(childComplexity int) int
  218	}
  219
  220	Label struct {
  221		Color func(childComplexity int) int
  222		Name  func(childComplexity int) int
  223	}
  224
  225	LabelChangeOperation struct {
  226		Added   func(childComplexity int) int
  227		Author  func(childComplexity int) int
  228		Date    func(childComplexity int) int
  229		ID      func(childComplexity int) int
  230		Removed func(childComplexity int) int
  231	}
  232
  233	LabelChangeResult struct {
  234		Label  func(childComplexity int) int
  235		Status func(childComplexity int) int
  236	}
  237
  238	LabelChangeTimelineItem struct {
  239		Added   func(childComplexity int) int
  240		Author  func(childComplexity int) int
  241		Date    func(childComplexity int) int
  242		ID      func(childComplexity int) int
  243		Removed func(childComplexity int) int
  244	}
  245
  246	LabelConnection struct {
  247		Edges      func(childComplexity int) int
  248		Nodes      func(childComplexity int) int
  249		PageInfo   func(childComplexity int) int
  250		TotalCount func(childComplexity int) int
  251	}
  252
  253	LabelEdge struct {
  254		Cursor func(childComplexity int) int
  255		Node   func(childComplexity int) int
  256	}
  257
  258	Mutation struct {
  259		AddComment   func(childComplexity int, input models.AddCommentInput) int
  260		ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
  261		CloseBug     func(childComplexity int, input models.CloseBugInput) int
  262		NewBug       func(childComplexity int, input models.NewBugInput) int
  263		OpenBug      func(childComplexity int, input models.OpenBugInput) int
  264		SetTitle     func(childComplexity int, input models.SetTitleInput) int
  265	}
  266
  267	NewBugPayload struct {
  268		Bug              func(childComplexity int) int
  269		ClientMutationID func(childComplexity int) int
  270		Operation        func(childComplexity int) int
  271	}
  272
  273	OpenBugPayload struct {
  274		Bug              func(childComplexity int) int
  275		ClientMutationID func(childComplexity int) int
  276		Operation        func(childComplexity int) int
  277	}
  278
  279	OperationConnection struct {
  280		Edges      func(childComplexity int) int
  281		Nodes      func(childComplexity int) int
  282		PageInfo   func(childComplexity int) int
  283		TotalCount func(childComplexity int) int
  284	}
  285
  286	OperationEdge struct {
  287		Cursor func(childComplexity int) int
  288		Node   func(childComplexity int) int
  289	}
  290
  291	PageInfo struct {
  292		EndCursor       func(childComplexity int) int
  293		HasNextPage     func(childComplexity int) int
  294		HasPreviousPage func(childComplexity int) int
  295		StartCursor     func(childComplexity int) int
  296	}
  297
  298	Query struct {
  299		Repository func(childComplexity int, ref *string) int
  300	}
  301
  302	Repository struct {
  303		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  304		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  305		Bug           func(childComplexity int, prefix string) int
  306		Identity      func(childComplexity int, prefix string) int
  307		Name          func(childComplexity int) int
  308		UserIdentity  func(childComplexity int) int
  309		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  310	}
  311
  312	SetStatusOperation struct {
  313		Author func(childComplexity int) int
  314		Date   func(childComplexity int) int
  315		ID     func(childComplexity int) int
  316		Status func(childComplexity int) int
  317	}
  318
  319	SetStatusTimelineItem struct {
  320		Author func(childComplexity int) int
  321		Date   func(childComplexity int) int
  322		ID     func(childComplexity int) int
  323		Status func(childComplexity int) int
  324	}
  325
  326	SetTitleOperation struct {
  327		Author func(childComplexity int) int
  328		Date   func(childComplexity int) int
  329		ID     func(childComplexity int) int
  330		Title  func(childComplexity int) int
  331		Was    func(childComplexity int) int
  332	}
  333
  334	SetTitlePayload struct {
  335		Bug              func(childComplexity int) int
  336		ClientMutationID func(childComplexity int) int
  337		Operation        func(childComplexity int) int
  338	}
  339
  340	SetTitleTimelineItem struct {
  341		Author func(childComplexity int) int
  342		Date   func(childComplexity int) int
  343		ID     func(childComplexity int) int
  344		Title  func(childComplexity int) int
  345		Was    func(childComplexity int) int
  346	}
  347
  348	TimelineItemConnection struct {
  349		Edges      func(childComplexity int) int
  350		Nodes      func(childComplexity int) int
  351		PageInfo   func(childComplexity int) int
  352		TotalCount func(childComplexity int) int
  353	}
  354
  355	TimelineItemEdge struct {
  356		Cursor func(childComplexity int) int
  357		Node   func(childComplexity int) int
  358	}
  359}
  360
  361type AddCommentOperationResolver interface {
  362	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  363	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
  364	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  365}
  366type AddCommentTimelineItemResolver interface {
  367	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  368	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
  369
  370	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  371	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  372}
  373type BugResolver interface {
  374	ID(ctx context.Context, obj models.BugWrapper) (string, error)
  375	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  376	Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
  377
  378	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  379	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  380	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  381	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  382	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  383}
  384type ColorResolver interface {
  385	R(ctx context.Context, obj *color.RGBA) (int, error)
  386	G(ctx context.Context, obj *color.RGBA) (int, error)
  387	B(ctx context.Context, obj *color.RGBA) (int, error)
  388}
  389type CommentResolver interface {
  390	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
  391}
  392type CommentHistoryStepResolver interface {
  393	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  394}
  395type CreateOperationResolver interface {
  396	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  397	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
  398	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  399}
  400type CreateTimelineItemResolver interface {
  401	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  402	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
  403
  404	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  405	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  406}
  407type EditCommentOperationResolver interface {
  408	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  409	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
  410	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  411	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  412}
  413type IdentityResolver interface {
  414	ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  415	HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  416}
  417type LabelResolver interface {
  418	Name(ctx context.Context, obj *bug.Label) (string, error)
  419	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  420}
  421type LabelChangeOperationResolver interface {
  422	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  423	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
  424	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  425}
  426type LabelChangeResultResolver interface {
  427	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  428}
  429type LabelChangeTimelineItemResolver interface {
  430	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  431	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
  432	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  433}
  434type MutationResolver interface {
  435	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  436	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  437	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  438	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  439	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  440	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  441}
  442type QueryResolver interface {
  443	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  444}
  445type RepositoryResolver interface {
  446	Name(ctx context.Context, obj *models.Repository) (*string, error)
  447	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  448	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  449	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  450	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  451	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  452	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  453}
  454type SetStatusOperationResolver interface {
  455	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  456	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
  457	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  458	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  459}
  460type SetStatusTimelineItemResolver interface {
  461	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  462	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
  463	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  464	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  465}
  466type SetTitleOperationResolver interface {
  467	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  468	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
  469	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  470}
  471type SetTitleTimelineItemResolver interface {
  472	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  473	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
  474	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  475}
  476
  477type executableSchema struct {
  478	resolvers  ResolverRoot
  479	directives DirectiveRoot
  480	complexity ComplexityRoot
  481}
  482
  483func (e *executableSchema) Schema() *ast.Schema {
  484	return parsedSchema
  485}
  486
  487func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  488	ec := executionContext{nil, e}
  489	_ = ec
  490	switch typeName + "." + field {
  491
  492	case "AddCommentOperation.author":
  493		if e.complexity.AddCommentOperation.Author == nil {
  494			break
  495		}
  496
  497		return e.complexity.AddCommentOperation.Author(childComplexity), true
  498
  499	case "AddCommentOperation.date":
  500		if e.complexity.AddCommentOperation.Date == nil {
  501			break
  502		}
  503
  504		return e.complexity.AddCommentOperation.Date(childComplexity), true
  505
  506	case "AddCommentOperation.files":
  507		if e.complexity.AddCommentOperation.Files == nil {
  508			break
  509		}
  510
  511		return e.complexity.AddCommentOperation.Files(childComplexity), true
  512
  513	case "AddCommentOperation.id":
  514		if e.complexity.AddCommentOperation.ID == nil {
  515			break
  516		}
  517
  518		return e.complexity.AddCommentOperation.ID(childComplexity), true
  519
  520	case "AddCommentOperation.message":
  521		if e.complexity.AddCommentOperation.Message == nil {
  522			break
  523		}
  524
  525		return e.complexity.AddCommentOperation.Message(childComplexity), true
  526
  527	case "AddCommentPayload.bug":
  528		if e.complexity.AddCommentPayload.Bug == nil {
  529			break
  530		}
  531
  532		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  533
  534	case "AddCommentPayload.clientMutationId":
  535		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  536			break
  537		}
  538
  539		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  540
  541	case "AddCommentPayload.operation":
  542		if e.complexity.AddCommentPayload.Operation == nil {
  543			break
  544		}
  545
  546		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  547
  548	case "AddCommentTimelineItem.author":
  549		if e.complexity.AddCommentTimelineItem.Author == nil {
  550			break
  551		}
  552
  553		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  554
  555	case "AddCommentTimelineItem.createdAt":
  556		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  557			break
  558		}
  559
  560		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  561
  562	case "AddCommentTimelineItem.edited":
  563		if e.complexity.AddCommentTimelineItem.Edited == nil {
  564			break
  565		}
  566
  567		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  568
  569	case "AddCommentTimelineItem.files":
  570		if e.complexity.AddCommentTimelineItem.Files == nil {
  571			break
  572		}
  573
  574		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  575
  576	case "AddCommentTimelineItem.history":
  577		if e.complexity.AddCommentTimelineItem.History == nil {
  578			break
  579		}
  580
  581		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  582
  583	case "AddCommentTimelineItem.id":
  584		if e.complexity.AddCommentTimelineItem.ID == nil {
  585			break
  586		}
  587
  588		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  589
  590	case "AddCommentTimelineItem.lastEdit":
  591		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  592			break
  593		}
  594
  595		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  596
  597	case "AddCommentTimelineItem.message":
  598		if e.complexity.AddCommentTimelineItem.Message == nil {
  599			break
  600		}
  601
  602		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  603
  604	case "AddCommentTimelineItem.messageIsEmpty":
  605		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  606			break
  607		}
  608
  609		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  610
  611	case "Bug.actors":
  612		if e.complexity.Bug.Actors == nil {
  613			break
  614		}
  615
  616		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  617		if err != nil {
  618			return 0, false
  619		}
  620
  621		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  622
  623	case "Bug.author":
  624		if e.complexity.Bug.Author == nil {
  625			break
  626		}
  627
  628		return e.complexity.Bug.Author(childComplexity), true
  629
  630	case "Bug.comments":
  631		if e.complexity.Bug.Comments == nil {
  632			break
  633		}
  634
  635		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  636		if err != nil {
  637			return 0, false
  638		}
  639
  640		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  641
  642	case "Bug.createdAt":
  643		if e.complexity.Bug.CreatedAt == nil {
  644			break
  645		}
  646
  647		return e.complexity.Bug.CreatedAt(childComplexity), true
  648
  649	case "Bug.humanId":
  650		if e.complexity.Bug.HumanID == nil {
  651			break
  652		}
  653
  654		return e.complexity.Bug.HumanID(childComplexity), true
  655
  656	case "Bug.id":
  657		if e.complexity.Bug.ID == nil {
  658			break
  659		}
  660
  661		return e.complexity.Bug.ID(childComplexity), true
  662
  663	case "Bug.labels":
  664		if e.complexity.Bug.Labels == nil {
  665			break
  666		}
  667
  668		return e.complexity.Bug.Labels(childComplexity), true
  669
  670	case "Bug.lastEdit":
  671		if e.complexity.Bug.LastEdit == nil {
  672			break
  673		}
  674
  675		return e.complexity.Bug.LastEdit(childComplexity), true
  676
  677	case "Bug.operations":
  678		if e.complexity.Bug.Operations == nil {
  679			break
  680		}
  681
  682		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  683		if err != nil {
  684			return 0, false
  685		}
  686
  687		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  688
  689	case "Bug.participants":
  690		if e.complexity.Bug.Participants == nil {
  691			break
  692		}
  693
  694		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  695		if err != nil {
  696			return 0, false
  697		}
  698
  699		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  700
  701	case "Bug.status":
  702		if e.complexity.Bug.Status == nil {
  703			break
  704		}
  705
  706		return e.complexity.Bug.Status(childComplexity), true
  707
  708	case "Bug.timeline":
  709		if e.complexity.Bug.Timeline == nil {
  710			break
  711		}
  712
  713		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  714		if err != nil {
  715			return 0, false
  716		}
  717
  718		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  719
  720	case "Bug.title":
  721		if e.complexity.Bug.Title == nil {
  722			break
  723		}
  724
  725		return e.complexity.Bug.Title(childComplexity), true
  726
  727	case "BugConnection.edges":
  728		if e.complexity.BugConnection.Edges == nil {
  729			break
  730		}
  731
  732		return e.complexity.BugConnection.Edges(childComplexity), true
  733
  734	case "BugConnection.nodes":
  735		if e.complexity.BugConnection.Nodes == nil {
  736			break
  737		}
  738
  739		return e.complexity.BugConnection.Nodes(childComplexity), true
  740
  741	case "BugConnection.pageInfo":
  742		if e.complexity.BugConnection.PageInfo == nil {
  743			break
  744		}
  745
  746		return e.complexity.BugConnection.PageInfo(childComplexity), true
  747
  748	case "BugConnection.totalCount":
  749		if e.complexity.BugConnection.TotalCount == nil {
  750			break
  751		}
  752
  753		return e.complexity.BugConnection.TotalCount(childComplexity), true
  754
  755	case "BugEdge.cursor":
  756		if e.complexity.BugEdge.Cursor == nil {
  757			break
  758		}
  759
  760		return e.complexity.BugEdge.Cursor(childComplexity), true
  761
  762	case "BugEdge.node":
  763		if e.complexity.BugEdge.Node == nil {
  764			break
  765		}
  766
  767		return e.complexity.BugEdge.Node(childComplexity), true
  768
  769	case "ChangeLabelPayload.bug":
  770		if e.complexity.ChangeLabelPayload.Bug == nil {
  771			break
  772		}
  773
  774		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  775
  776	case "ChangeLabelPayload.clientMutationId":
  777		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  778			break
  779		}
  780
  781		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  782
  783	case "ChangeLabelPayload.operation":
  784		if e.complexity.ChangeLabelPayload.Operation == nil {
  785			break
  786		}
  787
  788		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  789
  790	case "ChangeLabelPayload.results":
  791		if e.complexity.ChangeLabelPayload.Results == nil {
  792			break
  793		}
  794
  795		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  796
  797	case "CloseBugPayload.bug":
  798		if e.complexity.CloseBugPayload.Bug == nil {
  799			break
  800		}
  801
  802		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  803
  804	case "CloseBugPayload.clientMutationId":
  805		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  806			break
  807		}
  808
  809		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  810
  811	case "CloseBugPayload.operation":
  812		if e.complexity.CloseBugPayload.Operation == nil {
  813			break
  814		}
  815
  816		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  817
  818	case "Color.B":
  819		if e.complexity.Color.B == nil {
  820			break
  821		}
  822
  823		return e.complexity.Color.B(childComplexity), true
  824
  825	case "Color.G":
  826		if e.complexity.Color.G == nil {
  827			break
  828		}
  829
  830		return e.complexity.Color.G(childComplexity), true
  831
  832	case "Color.R":
  833		if e.complexity.Color.R == nil {
  834			break
  835		}
  836
  837		return e.complexity.Color.R(childComplexity), true
  838
  839	case "Comment.author":
  840		if e.complexity.Comment.Author == nil {
  841			break
  842		}
  843
  844		return e.complexity.Comment.Author(childComplexity), true
  845
  846	case "Comment.files":
  847		if e.complexity.Comment.Files == nil {
  848			break
  849		}
  850
  851		return e.complexity.Comment.Files(childComplexity), true
  852
  853	case "Comment.message":
  854		if e.complexity.Comment.Message == nil {
  855			break
  856		}
  857
  858		return e.complexity.Comment.Message(childComplexity), true
  859
  860	case "CommentConnection.edges":
  861		if e.complexity.CommentConnection.Edges == nil {
  862			break
  863		}
  864
  865		return e.complexity.CommentConnection.Edges(childComplexity), true
  866
  867	case "CommentConnection.nodes":
  868		if e.complexity.CommentConnection.Nodes == nil {
  869			break
  870		}
  871
  872		return e.complexity.CommentConnection.Nodes(childComplexity), true
  873
  874	case "CommentConnection.pageInfo":
  875		if e.complexity.CommentConnection.PageInfo == nil {
  876			break
  877		}
  878
  879		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  880
  881	case "CommentConnection.totalCount":
  882		if e.complexity.CommentConnection.TotalCount == nil {
  883			break
  884		}
  885
  886		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  887
  888	case "CommentEdge.cursor":
  889		if e.complexity.CommentEdge.Cursor == nil {
  890			break
  891		}
  892
  893		return e.complexity.CommentEdge.Cursor(childComplexity), true
  894
  895	case "CommentEdge.node":
  896		if e.complexity.CommentEdge.Node == nil {
  897			break
  898		}
  899
  900		return e.complexity.CommentEdge.Node(childComplexity), true
  901
  902	case "CommentHistoryStep.date":
  903		if e.complexity.CommentHistoryStep.Date == nil {
  904			break
  905		}
  906
  907		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  908
  909	case "CommentHistoryStep.message":
  910		if e.complexity.CommentHistoryStep.Message == nil {
  911			break
  912		}
  913
  914		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  915
  916	case "CreateOperation.author":
  917		if e.complexity.CreateOperation.Author == nil {
  918			break
  919		}
  920
  921		return e.complexity.CreateOperation.Author(childComplexity), true
  922
  923	case "CreateOperation.date":
  924		if e.complexity.CreateOperation.Date == nil {
  925			break
  926		}
  927
  928		return e.complexity.CreateOperation.Date(childComplexity), true
  929
  930	case "CreateOperation.files":
  931		if e.complexity.CreateOperation.Files == nil {
  932			break
  933		}
  934
  935		return e.complexity.CreateOperation.Files(childComplexity), true
  936
  937	case "CreateOperation.id":
  938		if e.complexity.CreateOperation.ID == nil {
  939			break
  940		}
  941
  942		return e.complexity.CreateOperation.ID(childComplexity), true
  943
  944	case "CreateOperation.message":
  945		if e.complexity.CreateOperation.Message == nil {
  946			break
  947		}
  948
  949		return e.complexity.CreateOperation.Message(childComplexity), true
  950
  951	case "CreateOperation.title":
  952		if e.complexity.CreateOperation.Title == nil {
  953			break
  954		}
  955
  956		return e.complexity.CreateOperation.Title(childComplexity), true
  957
  958	case "CreateTimelineItem.author":
  959		if e.complexity.CreateTimelineItem.Author == nil {
  960			break
  961		}
  962
  963		return e.complexity.CreateTimelineItem.Author(childComplexity), true
  964
  965	case "CreateTimelineItem.createdAt":
  966		if e.complexity.CreateTimelineItem.CreatedAt == nil {
  967			break
  968		}
  969
  970		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
  971
  972	case "CreateTimelineItem.edited":
  973		if e.complexity.CreateTimelineItem.Edited == nil {
  974			break
  975		}
  976
  977		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
  978
  979	case "CreateTimelineItem.files":
  980		if e.complexity.CreateTimelineItem.Files == nil {
  981			break
  982		}
  983
  984		return e.complexity.CreateTimelineItem.Files(childComplexity), true
  985
  986	case "CreateTimelineItem.history":
  987		if e.complexity.CreateTimelineItem.History == nil {
  988			break
  989		}
  990
  991		return e.complexity.CreateTimelineItem.History(childComplexity), true
  992
  993	case "CreateTimelineItem.id":
  994		if e.complexity.CreateTimelineItem.ID == nil {
  995			break
  996		}
  997
  998		return e.complexity.CreateTimelineItem.ID(childComplexity), true
  999
 1000	case "CreateTimelineItem.lastEdit":
 1001		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1002			break
 1003		}
 1004
 1005		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1006
 1007	case "CreateTimelineItem.message":
 1008		if e.complexity.CreateTimelineItem.Message == nil {
 1009			break
 1010		}
 1011
 1012		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1013
 1014	case "CreateTimelineItem.messageIsEmpty":
 1015		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1016			break
 1017		}
 1018
 1019		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1020
 1021	case "EditCommentOperation.author":
 1022		if e.complexity.EditCommentOperation.Author == nil {
 1023			break
 1024		}
 1025
 1026		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1027
 1028	case "EditCommentOperation.date":
 1029		if e.complexity.EditCommentOperation.Date == nil {
 1030			break
 1031		}
 1032
 1033		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1034
 1035	case "EditCommentOperation.files":
 1036		if e.complexity.EditCommentOperation.Files == nil {
 1037			break
 1038		}
 1039
 1040		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1041
 1042	case "EditCommentOperation.id":
 1043		if e.complexity.EditCommentOperation.ID == nil {
 1044			break
 1045		}
 1046
 1047		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1048
 1049	case "EditCommentOperation.message":
 1050		if e.complexity.EditCommentOperation.Message == nil {
 1051			break
 1052		}
 1053
 1054		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1055
 1056	case "EditCommentOperation.target":
 1057		if e.complexity.EditCommentOperation.Target == nil {
 1058			break
 1059		}
 1060
 1061		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1062
 1063	case "Identity.avatarUrl":
 1064		if e.complexity.Identity.AvatarUrl == nil {
 1065			break
 1066		}
 1067
 1068		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1069
 1070	case "Identity.displayName":
 1071		if e.complexity.Identity.DisplayName == nil {
 1072			break
 1073		}
 1074
 1075		return e.complexity.Identity.DisplayName(childComplexity), true
 1076
 1077	case "Identity.email":
 1078		if e.complexity.Identity.Email == nil {
 1079			break
 1080		}
 1081
 1082		return e.complexity.Identity.Email(childComplexity), true
 1083
 1084	case "Identity.humanId":
 1085		if e.complexity.Identity.HumanID == nil {
 1086			break
 1087		}
 1088
 1089		return e.complexity.Identity.HumanID(childComplexity), true
 1090
 1091	case "Identity.id":
 1092		if e.complexity.Identity.ID == nil {
 1093			break
 1094		}
 1095
 1096		return e.complexity.Identity.ID(childComplexity), true
 1097
 1098	case "Identity.isProtected":
 1099		if e.complexity.Identity.IsProtected == nil {
 1100			break
 1101		}
 1102
 1103		return e.complexity.Identity.IsProtected(childComplexity), true
 1104
 1105	case "Identity.login":
 1106		if e.complexity.Identity.Login == nil {
 1107			break
 1108		}
 1109
 1110		return e.complexity.Identity.Login(childComplexity), true
 1111
 1112	case "Identity.name":
 1113		if e.complexity.Identity.Name == nil {
 1114			break
 1115		}
 1116
 1117		return e.complexity.Identity.Name(childComplexity), true
 1118
 1119	case "IdentityConnection.edges":
 1120		if e.complexity.IdentityConnection.Edges == nil {
 1121			break
 1122		}
 1123
 1124		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1125
 1126	case "IdentityConnection.nodes":
 1127		if e.complexity.IdentityConnection.Nodes == nil {
 1128			break
 1129		}
 1130
 1131		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1132
 1133	case "IdentityConnection.pageInfo":
 1134		if e.complexity.IdentityConnection.PageInfo == nil {
 1135			break
 1136		}
 1137
 1138		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1139
 1140	case "IdentityConnection.totalCount":
 1141		if e.complexity.IdentityConnection.TotalCount == nil {
 1142			break
 1143		}
 1144
 1145		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1146
 1147	case "IdentityEdge.cursor":
 1148		if e.complexity.IdentityEdge.Cursor == nil {
 1149			break
 1150		}
 1151
 1152		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1153
 1154	case "IdentityEdge.node":
 1155		if e.complexity.IdentityEdge.Node == nil {
 1156			break
 1157		}
 1158
 1159		return e.complexity.IdentityEdge.Node(childComplexity), true
 1160
 1161	case "Label.color":
 1162		if e.complexity.Label.Color == nil {
 1163			break
 1164		}
 1165
 1166		return e.complexity.Label.Color(childComplexity), true
 1167
 1168	case "Label.name":
 1169		if e.complexity.Label.Name == nil {
 1170			break
 1171		}
 1172
 1173		return e.complexity.Label.Name(childComplexity), true
 1174
 1175	case "LabelChangeOperation.added":
 1176		if e.complexity.LabelChangeOperation.Added == nil {
 1177			break
 1178		}
 1179
 1180		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1181
 1182	case "LabelChangeOperation.author":
 1183		if e.complexity.LabelChangeOperation.Author == nil {
 1184			break
 1185		}
 1186
 1187		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1188
 1189	case "LabelChangeOperation.date":
 1190		if e.complexity.LabelChangeOperation.Date == nil {
 1191			break
 1192		}
 1193
 1194		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1195
 1196	case "LabelChangeOperation.id":
 1197		if e.complexity.LabelChangeOperation.ID == nil {
 1198			break
 1199		}
 1200
 1201		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1202
 1203	case "LabelChangeOperation.removed":
 1204		if e.complexity.LabelChangeOperation.Removed == nil {
 1205			break
 1206		}
 1207
 1208		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1209
 1210	case "LabelChangeResult.label":
 1211		if e.complexity.LabelChangeResult.Label == nil {
 1212			break
 1213		}
 1214
 1215		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1216
 1217	case "LabelChangeResult.status":
 1218		if e.complexity.LabelChangeResult.Status == nil {
 1219			break
 1220		}
 1221
 1222		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1223
 1224	case "LabelChangeTimelineItem.added":
 1225		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1226			break
 1227		}
 1228
 1229		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1230
 1231	case "LabelChangeTimelineItem.author":
 1232		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1233			break
 1234		}
 1235
 1236		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1237
 1238	case "LabelChangeTimelineItem.date":
 1239		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1240			break
 1241		}
 1242
 1243		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1244
 1245	case "LabelChangeTimelineItem.id":
 1246		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1247			break
 1248		}
 1249
 1250		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1251
 1252	case "LabelChangeTimelineItem.removed":
 1253		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1254			break
 1255		}
 1256
 1257		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1258
 1259	case "LabelConnection.edges":
 1260		if e.complexity.LabelConnection.Edges == nil {
 1261			break
 1262		}
 1263
 1264		return e.complexity.LabelConnection.Edges(childComplexity), true
 1265
 1266	case "LabelConnection.nodes":
 1267		if e.complexity.LabelConnection.Nodes == nil {
 1268			break
 1269		}
 1270
 1271		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1272
 1273	case "LabelConnection.pageInfo":
 1274		if e.complexity.LabelConnection.PageInfo == nil {
 1275			break
 1276		}
 1277
 1278		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1279
 1280	case "LabelConnection.totalCount":
 1281		if e.complexity.LabelConnection.TotalCount == nil {
 1282			break
 1283		}
 1284
 1285		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1286
 1287	case "LabelEdge.cursor":
 1288		if e.complexity.LabelEdge.Cursor == nil {
 1289			break
 1290		}
 1291
 1292		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1293
 1294	case "LabelEdge.node":
 1295		if e.complexity.LabelEdge.Node == nil {
 1296			break
 1297		}
 1298
 1299		return e.complexity.LabelEdge.Node(childComplexity), true
 1300
 1301	case "Mutation.addComment":
 1302		if e.complexity.Mutation.AddComment == nil {
 1303			break
 1304		}
 1305
 1306		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1307		if err != nil {
 1308			return 0, false
 1309		}
 1310
 1311		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1312
 1313	case "Mutation.changeLabels":
 1314		if e.complexity.Mutation.ChangeLabels == nil {
 1315			break
 1316		}
 1317
 1318		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1319		if err != nil {
 1320			return 0, false
 1321		}
 1322
 1323		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1324
 1325	case "Mutation.closeBug":
 1326		if e.complexity.Mutation.CloseBug == nil {
 1327			break
 1328		}
 1329
 1330		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1331		if err != nil {
 1332			return 0, false
 1333		}
 1334
 1335		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1336
 1337	case "Mutation.newBug":
 1338		if e.complexity.Mutation.NewBug == nil {
 1339			break
 1340		}
 1341
 1342		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1343		if err != nil {
 1344			return 0, false
 1345		}
 1346
 1347		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1348
 1349	case "Mutation.openBug":
 1350		if e.complexity.Mutation.OpenBug == nil {
 1351			break
 1352		}
 1353
 1354		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1355		if err != nil {
 1356			return 0, false
 1357		}
 1358
 1359		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1360
 1361	case "Mutation.setTitle":
 1362		if e.complexity.Mutation.SetTitle == nil {
 1363			break
 1364		}
 1365
 1366		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1367		if err != nil {
 1368			return 0, false
 1369		}
 1370
 1371		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1372
 1373	case "NewBugPayload.bug":
 1374		if e.complexity.NewBugPayload.Bug == nil {
 1375			break
 1376		}
 1377
 1378		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1379
 1380	case "NewBugPayload.clientMutationId":
 1381		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1382			break
 1383		}
 1384
 1385		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1386
 1387	case "NewBugPayload.operation":
 1388		if e.complexity.NewBugPayload.Operation == nil {
 1389			break
 1390		}
 1391
 1392		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1393
 1394	case "OpenBugPayload.bug":
 1395		if e.complexity.OpenBugPayload.Bug == nil {
 1396			break
 1397		}
 1398
 1399		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1400
 1401	case "OpenBugPayload.clientMutationId":
 1402		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1403			break
 1404		}
 1405
 1406		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1407
 1408	case "OpenBugPayload.operation":
 1409		if e.complexity.OpenBugPayload.Operation == nil {
 1410			break
 1411		}
 1412
 1413		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1414
 1415	case "OperationConnection.edges":
 1416		if e.complexity.OperationConnection.Edges == nil {
 1417			break
 1418		}
 1419
 1420		return e.complexity.OperationConnection.Edges(childComplexity), true
 1421
 1422	case "OperationConnection.nodes":
 1423		if e.complexity.OperationConnection.Nodes == nil {
 1424			break
 1425		}
 1426
 1427		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1428
 1429	case "OperationConnection.pageInfo":
 1430		if e.complexity.OperationConnection.PageInfo == nil {
 1431			break
 1432		}
 1433
 1434		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1435
 1436	case "OperationConnection.totalCount":
 1437		if e.complexity.OperationConnection.TotalCount == nil {
 1438			break
 1439		}
 1440
 1441		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1442
 1443	case "OperationEdge.cursor":
 1444		if e.complexity.OperationEdge.Cursor == nil {
 1445			break
 1446		}
 1447
 1448		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1449
 1450	case "OperationEdge.node":
 1451		if e.complexity.OperationEdge.Node == nil {
 1452			break
 1453		}
 1454
 1455		return e.complexity.OperationEdge.Node(childComplexity), true
 1456
 1457	case "PageInfo.endCursor":
 1458		if e.complexity.PageInfo.EndCursor == nil {
 1459			break
 1460		}
 1461
 1462		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1463
 1464	case "PageInfo.hasNextPage":
 1465		if e.complexity.PageInfo.HasNextPage == nil {
 1466			break
 1467		}
 1468
 1469		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1470
 1471	case "PageInfo.hasPreviousPage":
 1472		if e.complexity.PageInfo.HasPreviousPage == nil {
 1473			break
 1474		}
 1475
 1476		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1477
 1478	case "PageInfo.startCursor":
 1479		if e.complexity.PageInfo.StartCursor == nil {
 1480			break
 1481		}
 1482
 1483		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1484
 1485	case "Query.repository":
 1486		if e.complexity.Query.Repository == nil {
 1487			break
 1488		}
 1489
 1490		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1491		if err != nil {
 1492			return 0, false
 1493		}
 1494
 1495		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 1496
 1497	case "Repository.allBugs":
 1498		if e.complexity.Repository.AllBugs == nil {
 1499			break
 1500		}
 1501
 1502		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1503		if err != nil {
 1504			return 0, false
 1505		}
 1506
 1507		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1508
 1509	case "Repository.allIdentities":
 1510		if e.complexity.Repository.AllIdentities == nil {
 1511			break
 1512		}
 1513
 1514		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1515		if err != nil {
 1516			return 0, false
 1517		}
 1518
 1519		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1520
 1521	case "Repository.bug":
 1522		if e.complexity.Repository.Bug == nil {
 1523			break
 1524		}
 1525
 1526		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1527		if err != nil {
 1528			return 0, false
 1529		}
 1530
 1531		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1532
 1533	case "Repository.identity":
 1534		if e.complexity.Repository.Identity == nil {
 1535			break
 1536		}
 1537
 1538		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1539		if err != nil {
 1540			return 0, false
 1541		}
 1542
 1543		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1544
 1545	case "Repository.name":
 1546		if e.complexity.Repository.Name == nil {
 1547			break
 1548		}
 1549
 1550		return e.complexity.Repository.Name(childComplexity), true
 1551
 1552	case "Repository.userIdentity":
 1553		if e.complexity.Repository.UserIdentity == nil {
 1554			break
 1555		}
 1556
 1557		return e.complexity.Repository.UserIdentity(childComplexity), true
 1558
 1559	case "Repository.validLabels":
 1560		if e.complexity.Repository.ValidLabels == nil {
 1561			break
 1562		}
 1563
 1564		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1565		if err != nil {
 1566			return 0, false
 1567		}
 1568
 1569		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1570
 1571	case "SetStatusOperation.author":
 1572		if e.complexity.SetStatusOperation.Author == nil {
 1573			break
 1574		}
 1575
 1576		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1577
 1578	case "SetStatusOperation.date":
 1579		if e.complexity.SetStatusOperation.Date == nil {
 1580			break
 1581		}
 1582
 1583		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1584
 1585	case "SetStatusOperation.id":
 1586		if e.complexity.SetStatusOperation.ID == nil {
 1587			break
 1588		}
 1589
 1590		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1591
 1592	case "SetStatusOperation.status":
 1593		if e.complexity.SetStatusOperation.Status == nil {
 1594			break
 1595		}
 1596
 1597		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1598
 1599	case "SetStatusTimelineItem.author":
 1600		if e.complexity.SetStatusTimelineItem.Author == nil {
 1601			break
 1602		}
 1603
 1604		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1605
 1606	case "SetStatusTimelineItem.date":
 1607		if e.complexity.SetStatusTimelineItem.Date == nil {
 1608			break
 1609		}
 1610
 1611		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1612
 1613	case "SetStatusTimelineItem.id":
 1614		if e.complexity.SetStatusTimelineItem.ID == nil {
 1615			break
 1616		}
 1617
 1618		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1619
 1620	case "SetStatusTimelineItem.status":
 1621		if e.complexity.SetStatusTimelineItem.Status == nil {
 1622			break
 1623		}
 1624
 1625		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1626
 1627	case "SetTitleOperation.author":
 1628		if e.complexity.SetTitleOperation.Author == nil {
 1629			break
 1630		}
 1631
 1632		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1633
 1634	case "SetTitleOperation.date":
 1635		if e.complexity.SetTitleOperation.Date == nil {
 1636			break
 1637		}
 1638
 1639		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1640
 1641	case "SetTitleOperation.id":
 1642		if e.complexity.SetTitleOperation.ID == nil {
 1643			break
 1644		}
 1645
 1646		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1647
 1648	case "SetTitleOperation.title":
 1649		if e.complexity.SetTitleOperation.Title == nil {
 1650			break
 1651		}
 1652
 1653		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1654
 1655	case "SetTitleOperation.was":
 1656		if e.complexity.SetTitleOperation.Was == nil {
 1657			break
 1658		}
 1659
 1660		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1661
 1662	case "SetTitlePayload.bug":
 1663		if e.complexity.SetTitlePayload.Bug == nil {
 1664			break
 1665		}
 1666
 1667		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1668
 1669	case "SetTitlePayload.clientMutationId":
 1670		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1671			break
 1672		}
 1673
 1674		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1675
 1676	case "SetTitlePayload.operation":
 1677		if e.complexity.SetTitlePayload.Operation == nil {
 1678			break
 1679		}
 1680
 1681		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1682
 1683	case "SetTitleTimelineItem.author":
 1684		if e.complexity.SetTitleTimelineItem.Author == nil {
 1685			break
 1686		}
 1687
 1688		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1689
 1690	case "SetTitleTimelineItem.date":
 1691		if e.complexity.SetTitleTimelineItem.Date == nil {
 1692			break
 1693		}
 1694
 1695		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1696
 1697	case "SetTitleTimelineItem.id":
 1698		if e.complexity.SetTitleTimelineItem.ID == nil {
 1699			break
 1700		}
 1701
 1702		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1703
 1704	case "SetTitleTimelineItem.title":
 1705		if e.complexity.SetTitleTimelineItem.Title == nil {
 1706			break
 1707		}
 1708
 1709		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1710
 1711	case "SetTitleTimelineItem.was":
 1712		if e.complexity.SetTitleTimelineItem.Was == nil {
 1713			break
 1714		}
 1715
 1716		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1717
 1718	case "TimelineItemConnection.edges":
 1719		if e.complexity.TimelineItemConnection.Edges == nil {
 1720			break
 1721		}
 1722
 1723		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1724
 1725	case "TimelineItemConnection.nodes":
 1726		if e.complexity.TimelineItemConnection.Nodes == nil {
 1727			break
 1728		}
 1729
 1730		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1731
 1732	case "TimelineItemConnection.pageInfo":
 1733		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1734			break
 1735		}
 1736
 1737		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1738
 1739	case "TimelineItemConnection.totalCount":
 1740		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1741			break
 1742		}
 1743
 1744		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1745
 1746	case "TimelineItemEdge.cursor":
 1747		if e.complexity.TimelineItemEdge.Cursor == nil {
 1748			break
 1749		}
 1750
 1751		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1752
 1753	case "TimelineItemEdge.node":
 1754		if e.complexity.TimelineItemEdge.Node == nil {
 1755			break
 1756		}
 1757
 1758		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1759
 1760	}
 1761	return 0, false
 1762}
 1763
 1764func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1765	rc := graphql.GetOperationContext(ctx)
 1766	ec := executionContext{rc, e}
 1767	first := true
 1768
 1769	switch rc.Operation.Operation {
 1770	case ast.Query:
 1771		return func(ctx context.Context) *graphql.Response {
 1772			if !first {
 1773				return nil
 1774			}
 1775			first = false
 1776			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1777			var buf bytes.Buffer
 1778			data.MarshalGQL(&buf)
 1779
 1780			return &graphql.Response{
 1781				Data: buf.Bytes(),
 1782			}
 1783		}
 1784	case ast.Mutation:
 1785		return func(ctx context.Context) *graphql.Response {
 1786			if !first {
 1787				return nil
 1788			}
 1789			first = false
 1790			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1791			var buf bytes.Buffer
 1792			data.MarshalGQL(&buf)
 1793
 1794			return &graphql.Response{
 1795				Data: buf.Bytes(),
 1796			}
 1797		}
 1798
 1799	default:
 1800		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1801	}
 1802}
 1803
 1804type executionContext struct {
 1805	*graphql.OperationContext
 1806	*executableSchema
 1807}
 1808
 1809func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1810	if ec.DisableIntrospection {
 1811		return nil, errors.New("introspection disabled")
 1812	}
 1813	return introspection.WrapSchema(parsedSchema), nil
 1814}
 1815
 1816func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1817	if ec.DisableIntrospection {
 1818		return nil, errors.New("introspection disabled")
 1819	}
 1820	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1821}
 1822
 1823var sources = []*ast.Source{
 1824	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1825type Comment implements Authored {
 1826  """The author of this comment."""
 1827  author: Identity!
 1828
 1829  """The message of this comment."""
 1830  message: String!
 1831
 1832  """All media's hash referenced in this comment"""
 1833  files: [Hash!]!
 1834}
 1835
 1836type CommentConnection {
 1837  edges: [CommentEdge!]!
 1838  nodes: [Comment!]!
 1839  pageInfo: PageInfo!
 1840  totalCount: Int!
 1841}
 1842
 1843type CommentEdge {
 1844  cursor: String!
 1845  node: Comment!
 1846}
 1847
 1848enum Status {
 1849  OPEN
 1850  CLOSED
 1851}
 1852
 1853type Bug implements Authored {
 1854  """The identifier for this bug"""
 1855  id: String!
 1856  """The human version (truncated) identifier for this bug"""
 1857  humanId: String!
 1858  status: Status!
 1859  title: String!
 1860  labels: [Label!]!
 1861  author: Identity!
 1862  createdAt: Time!
 1863  lastEdit: Time!
 1864
 1865  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1866  actors(
 1867    """Returns the elements in the list that come after the specified cursor."""
 1868    after: String
 1869    """Returns the elements in the list that come before the specified cursor."""
 1870    before: String
 1871    """Returns the first _n_ elements from the list."""
 1872    first: Int
 1873    """Returns the last _n_ elements from the list."""
 1874    last: Int
 1875  ): IdentityConnection!
 1876
 1877  """The participants of the bug. Participants are Identity that have created or
 1878  added a comment on the bug."""
 1879  participants(
 1880    """Returns the elements in the list that come after the specified cursor."""
 1881    after: String
 1882    """Returns the elements in the list that come before the specified cursor."""
 1883    before: String
 1884    """Returns the first _n_ elements from the list."""
 1885    first: Int
 1886    """Returns the last _n_ elements from the list."""
 1887    last: Int
 1888  ): IdentityConnection!
 1889
 1890  comments(
 1891    """Returns the elements in the list that come after the specified cursor."""
 1892    after: String
 1893    """Returns the elements in the list that come before the specified cursor."""
 1894    before: String
 1895    """Returns the first _n_ elements from the list."""
 1896    first: Int
 1897    """Returns the last _n_ elements from the list."""
 1898    last: Int
 1899  ): CommentConnection!
 1900
 1901  timeline(
 1902    """Returns the elements in the list that come after the specified cursor."""
 1903    after: String
 1904    """Returns the elements in the list that come before the specified cursor."""
 1905    before: String
 1906    """Returns the first _n_ elements from the list."""
 1907    first: Int
 1908    """Returns the last _n_ elements from the list."""
 1909    last: Int
 1910  ): TimelineItemConnection!
 1911
 1912  operations(
 1913    """Returns the elements in the list that come after the specified cursor."""
 1914    after: String
 1915    """Returns the elements in the list that come before the specified cursor."""
 1916    before: String
 1917    """Returns the first _n_ elements from the list."""
 1918    first: Int
 1919    """Returns the last _n_ elements from the list."""
 1920    last: Int
 1921  ): OperationConnection!
 1922}
 1923
 1924"""The connection type for Bug."""
 1925type BugConnection {
 1926  """A list of edges."""
 1927  edges: [BugEdge!]!
 1928  nodes: [Bug!]!
 1929  """Information to aid in pagination."""
 1930  pageInfo: PageInfo!
 1931  """Identifies the total count of items in the connection."""
 1932  totalCount: Int!
 1933}
 1934
 1935"""An edge in a connection."""
 1936type BugEdge {
 1937  """A cursor for use in pagination."""
 1938  cursor: String!
 1939  """The item at the end of the edge."""
 1940  node: Bug!
 1941}
 1942`, BuiltIn: false},
 1943	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1944type Identity {
 1945    """The identifier for this identity"""
 1946    id: String!
 1947    """The human version (truncated) identifier for this identity"""
 1948    humanId: String!
 1949    """The name of the person, if known."""
 1950    name: String
 1951    """The email of the person, if known."""
 1952    email: String
 1953    """The login of the person, if known."""
 1954    login: String
 1955    """A non-empty string to display, representing the identity, based on the non-empty values."""
 1956    displayName: String!
 1957    """An url to an avatar"""
 1958    avatarUrl: String
 1959    """isProtected is true if the chain of git commits started to be signed.
 1960    If that's the case, only signed commit with a valid key for this identity can be added."""
 1961    isProtected: Boolean!
 1962}
 1963
 1964type IdentityConnection {
 1965    edges: [IdentityEdge!]!
 1966    nodes: [Identity!]!
 1967    pageInfo: PageInfo!
 1968    totalCount: Int!
 1969}
 1970
 1971type IdentityEdge {
 1972    cursor: String!
 1973    node: Identity!
 1974}`, BuiltIn: false},
 1975	&ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
 1976type Label {
 1977    """The name of the label."""
 1978    name: String!
 1979    """Color of the label."""
 1980    color: Color!
 1981}
 1982
 1983type LabelConnection {
 1984    edges: [LabelEdge!]!
 1985    nodes: [Label!]!
 1986    pageInfo: PageInfo!
 1987    totalCount: Int!
 1988}
 1989
 1990type LabelEdge {
 1991    cursor: String!
 1992    node: Label!
 1993}`, BuiltIn: false},
 1994	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 1995    """A unique identifier for the client performing the mutation."""
 1996    clientMutationId: String
 1997    """"The name of the repository. If not set, the default repository is used."""
 1998    repoRef: String
 1999    """The title of the new bug."""
 2000    title: String!
 2001    """The first message of the new bug."""
 2002    message: String!
 2003    """The collection of file's hash required for the first message."""
 2004    files: [Hash!]
 2005}
 2006
 2007type NewBugPayload {
 2008    """A unique identifier for the client performing the mutation."""
 2009    clientMutationId: String
 2010    """The created bug."""
 2011    bug: Bug!
 2012    """The resulting operation."""
 2013    operation: CreateOperation!
 2014}
 2015
 2016input AddCommentInput {
 2017    """A unique identifier for the client performing the mutation."""
 2018    clientMutationId: String
 2019    """"The name of the repository. If not set, the default repository is used."""
 2020    repoRef: String
 2021    """The bug ID's prefix."""
 2022    prefix: String!
 2023    """The first message of the new bug."""
 2024    message: String!
 2025    """The collection of file's hash required for the first message."""
 2026    files: [Hash!]
 2027}
 2028
 2029type AddCommentPayload {
 2030    """A unique identifier for the client performing the mutation."""
 2031    clientMutationId: String
 2032    """The affected bug."""
 2033    bug: Bug!
 2034    """The resulting operation."""
 2035    operation: AddCommentOperation!
 2036}
 2037
 2038input ChangeLabelInput {
 2039    """A unique identifier for the client performing the mutation."""
 2040    clientMutationId: String
 2041    """"The name of the repository. If not set, the default repository is used."""
 2042    repoRef: String
 2043    """The bug ID's prefix."""
 2044    prefix: String!
 2045    """The list of label to add."""
 2046    added: [String!]
 2047    """The list of label to remove."""
 2048    Removed: [String!]
 2049}
 2050
 2051enum LabelChangeStatus {
 2052    ADDED
 2053    REMOVED
 2054    DUPLICATE_IN_OP
 2055    ALREADY_EXIST
 2056    DOESNT_EXIST
 2057}
 2058
 2059type LabelChangeResult {
 2060    """The source label."""
 2061    label: Label!
 2062    """The effect this label had."""
 2063    status: LabelChangeStatus!
 2064}
 2065
 2066type ChangeLabelPayload {
 2067    """A unique identifier for the client performing the mutation."""
 2068    clientMutationId: String
 2069    """The affected bug."""
 2070    bug: Bug!
 2071    """The resulting operation."""
 2072    operation: LabelChangeOperation!
 2073    """The effect each source label had."""
 2074    results: [LabelChangeResult]!
 2075}
 2076
 2077input OpenBugInput {
 2078    """A unique identifier for the client performing the mutation."""
 2079    clientMutationId: String
 2080    """"The name of the repository. If not set, the default repository is used."""
 2081    repoRef: String
 2082    """The bug ID's prefix."""
 2083    prefix: String!
 2084}
 2085
 2086type OpenBugPayload {
 2087    """A unique identifier for the client performing the mutation."""
 2088    clientMutationId: String
 2089    """The affected bug."""
 2090    bug: Bug!
 2091    """The resulting operation."""
 2092    operation: SetStatusOperation!
 2093}
 2094
 2095input CloseBugInput {
 2096    """A unique identifier for the client performing the mutation."""
 2097    clientMutationId: String
 2098    """"The name of the repository. If not set, the default repository is used."""
 2099    repoRef: String
 2100    """The bug ID's prefix."""
 2101    prefix: String!
 2102}
 2103
 2104type CloseBugPayload {
 2105    """A unique identifier for the client performing the mutation."""
 2106    clientMutationId: String
 2107    """The affected bug."""
 2108    bug: Bug!
 2109    """The resulting operation."""
 2110    operation: SetStatusOperation!
 2111}
 2112
 2113input SetTitleInput {
 2114    """A unique identifier for the client performing the mutation."""
 2115    clientMutationId: String
 2116    """"The name of the repository. If not set, the default repository is used."""
 2117    repoRef: String
 2118    """The bug ID's prefix."""
 2119    prefix: String!
 2120    """The new title."""
 2121    title: String!
 2122}
 2123
 2124type SetTitlePayload {
 2125    """A unique identifier for the client performing the mutation."""
 2126    clientMutationId: String
 2127    """The affected bug."""
 2128    bug: Bug!
 2129    """The resulting operation"""
 2130    operation: SetTitleOperation!
 2131}
 2132`, BuiltIn: false},
 2133	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2134interface Operation {
 2135    """The identifier of the operation"""
 2136    id: String!
 2137    """The operations author."""
 2138    author: Identity!
 2139    """The datetime when this operation was issued."""
 2140    date: Time!
 2141}
 2142
 2143# Connection
 2144
 2145"""The connection type for an Operation"""
 2146type OperationConnection {
 2147    edges: [OperationEdge!]!
 2148    nodes: [Operation!]!
 2149    pageInfo: PageInfo!
 2150    totalCount: Int!
 2151}
 2152
 2153"""Represent an Operation"""
 2154type OperationEdge {
 2155    cursor: String!
 2156    node: Operation!
 2157}
 2158
 2159# Operations
 2160
 2161type CreateOperation implements Operation & Authored {
 2162    """The identifier of the operation"""
 2163    id: String!
 2164    """The author of this object."""
 2165    author: Identity!
 2166    """The datetime when this operation was issued."""
 2167    date: Time!
 2168
 2169    title: String!
 2170    message: String!
 2171    files: [Hash!]!
 2172}
 2173
 2174type SetTitleOperation implements Operation & Authored {
 2175    """The identifier of the operation"""
 2176    id: String!
 2177    """The author of this object."""
 2178    author: Identity!
 2179    """The datetime when this operation was issued."""
 2180    date: Time!
 2181
 2182    title: String!
 2183    was: String!
 2184}
 2185
 2186type AddCommentOperation implements Operation & Authored {
 2187    """The identifier of the operation"""
 2188    id: String!
 2189    """The author of this object."""
 2190    author: Identity!
 2191    """The datetime when this operation was issued."""
 2192    date: Time!
 2193
 2194    message: String!
 2195    files: [Hash!]!
 2196}
 2197
 2198type EditCommentOperation implements Operation & Authored {
 2199    """The identifier of the operation"""
 2200    id: String!
 2201    """The author of this object."""
 2202    author: Identity!
 2203    """The datetime when this operation was issued."""
 2204    date: Time!
 2205
 2206    target: String!
 2207    message: String!
 2208    files: [Hash!]!
 2209}
 2210
 2211type SetStatusOperation implements Operation & Authored {
 2212    """The identifier of the operation"""
 2213    id: String!
 2214    """The author of this object."""
 2215    author: Identity!
 2216    """The datetime when this operation was issued."""
 2217    date: Time!
 2218
 2219    status: Status!
 2220}
 2221
 2222type LabelChangeOperation implements Operation & Authored {
 2223    """The identifier of the operation"""
 2224    id: String!
 2225    """The author of this object."""
 2226    author: Identity!
 2227    """The datetime when this operation was issued."""
 2228    date: Time!
 2229
 2230    added: [Label!]!
 2231    removed: [Label!]!
 2232}
 2233`, BuiltIn: false},
 2234	&ast.Source{Name: "schema/repository.graphql", Input: `
 2235type Repository {
 2236    """The name of the repository"""
 2237    name: String
 2238
 2239    """All the bugs"""
 2240    allBugs(
 2241        """Returns the elements in the list that come after the specified cursor."""
 2242        after: String
 2243        """Returns the elements in the list that come before the specified cursor."""
 2244        before: String
 2245        """Returns the first _n_ elements from the list."""
 2246        first: Int
 2247        """Returns the last _n_ elements from the list."""
 2248        last: Int
 2249        """A query to select and order bugs."""
 2250        query: String
 2251    ): BugConnection!
 2252
 2253    bug(prefix: String!): Bug
 2254
 2255    """All the identities"""
 2256    allIdentities(
 2257        """Returns the elements in the list that come after the specified cursor."""
 2258        after: String
 2259        """Returns the elements in the list that come before the specified cursor."""
 2260        before: String
 2261        """Returns the first _n_ elements from the list."""
 2262        first: Int
 2263        """Returns the last _n_ elements from the list."""
 2264        last: Int
 2265    ): IdentityConnection!
 2266
 2267    identity(prefix: String!): Identity
 2268
 2269    """The identity created or selected by the user as its own"""
 2270    userIdentity: Identity
 2271
 2272    """List of valid labels."""
 2273    validLabels(
 2274        """Returns the elements in the list that come after the specified cursor."""
 2275        after: String
 2276        """Returns the elements in the list that come before the specified cursor."""
 2277        before: String
 2278        """Returns the first _n_ elements from the list."""
 2279        first: Int
 2280        """Returns the last _n_ elements from the list."""
 2281        last: Int
 2282    ): LabelConnection!
 2283}`, BuiltIn: false},
 2284	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2285    """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
 2286    repository(ref: String): Repository
 2287}
 2288
 2289type Mutation {
 2290    """Create a new bug"""
 2291    newBug(input: NewBugInput!): NewBugPayload!
 2292    """Add a new comment to a bug"""
 2293    addComment(input: AddCommentInput!): AddCommentPayload!
 2294    """Add or remove a set of label on a bug"""
 2295    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2296    """Change a bug's status to open"""
 2297    openBug(input: OpenBugInput!): OpenBugPayload!
 2298    """Change a bug's status to closed"""
 2299    closeBug(input: CloseBugInput!): CloseBugPayload!
 2300    """Change a bug's title"""
 2301    setTitle(input: SetTitleInput!): SetTitlePayload!
 2302}
 2303`, BuiltIn: false},
 2304	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2305interface TimelineItem {
 2306    """The identifier of the source operation"""
 2307    id: String!
 2308}
 2309
 2310"""CommentHistoryStep hold one version of a message in the history"""
 2311type CommentHistoryStep {
 2312    message: String!
 2313    date: Time!
 2314}
 2315
 2316# Connection
 2317
 2318"""The connection type for TimelineItem"""
 2319type TimelineItemConnection {
 2320    edges: [TimelineItemEdge!]!
 2321    nodes: [TimelineItem!]!
 2322    pageInfo: PageInfo!
 2323    totalCount: Int!
 2324}
 2325
 2326"""Represent a TimelineItem"""
 2327type TimelineItemEdge {
 2328    cursor: String!
 2329    node: TimelineItem!
 2330}
 2331
 2332# Items
 2333
 2334"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2335type CreateTimelineItem implements TimelineItem & Authored {
 2336    """The identifier of the source operation"""
 2337    id: String!
 2338    author: Identity!
 2339    message: String!
 2340    messageIsEmpty: Boolean!
 2341    files: [Hash!]!
 2342    createdAt: Time!
 2343    lastEdit: Time!
 2344    edited: Boolean!
 2345    history: [CommentHistoryStep!]!
 2346}
 2347
 2348"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2349type AddCommentTimelineItem implements TimelineItem & Authored {
 2350    """The identifier of the source operation"""
 2351    id: String!
 2352    author: Identity!
 2353    message: String!
 2354    messageIsEmpty: Boolean!
 2355    files: [Hash!]!
 2356    createdAt: Time!
 2357    lastEdit: Time!
 2358    edited: Boolean!
 2359    history: [CommentHistoryStep!]!
 2360}
 2361
 2362"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2363type LabelChangeTimelineItem implements TimelineItem & Authored {
 2364    """The identifier of the source operation"""
 2365    id: String!
 2366    author: Identity!
 2367    date: Time!
 2368    added: [Label!]!
 2369    removed: [Label!]!
 2370}
 2371
 2372"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2373type SetStatusTimelineItem implements TimelineItem & Authored {
 2374    """The identifier of the source operation"""
 2375    id: String!
 2376    author: Identity!
 2377    date: Time!
 2378    status: Status!
 2379}
 2380
 2381"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2382type SetTitleTimelineItem implements TimelineItem & Authored {
 2383    """The identifier of the source operation"""
 2384    id: String!
 2385    author: Identity!
 2386    date: Time!
 2387    title: String!
 2388    was: String!
 2389}
 2390`, BuiltIn: false},
 2391	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2392scalar Hash
 2393
 2394"""Defines a color by red, green and blue components."""
 2395type Color {
 2396    """Red component of the color."""
 2397    R: Int!
 2398    """Green component of the color."""
 2399    G: Int!
 2400    """Blue component of the color."""
 2401    B: Int!
 2402}
 2403
 2404"""Information about pagination in a connection."""
 2405type PageInfo {
 2406    """When paginating forwards, are there more items?"""
 2407    hasNextPage: Boolean!
 2408    """When paginating backwards, are there more items?"""
 2409    hasPreviousPage: Boolean!
 2410    """When paginating backwards, the cursor to continue."""
 2411    startCursor: String!
 2412    """When paginating forwards, the cursor to continue."""
 2413    endCursor: String!
 2414}
 2415
 2416"""An object that has an author."""
 2417interface Authored {
 2418    """The author of this object."""
 2419    author: Identity!
 2420}
 2421`, BuiltIn: false},
 2422}
 2423var parsedSchema = gqlparser.MustLoadSchema(sources...)
 2424
 2425// endregion ************************** generated!.gotpl **************************
 2426
 2427// region    ***************************** args.gotpl *****************************
 2428
 2429func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2430	var err error
 2431	args := map[string]interface{}{}
 2432	var arg0 *string
 2433	if tmp, ok := rawArgs["after"]; ok {
 2434		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2435		if err != nil {
 2436			return nil, err
 2437		}
 2438	}
 2439	args["after"] = arg0
 2440	var arg1 *string
 2441	if tmp, ok := rawArgs["before"]; ok {
 2442		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2443		if err != nil {
 2444			return nil, err
 2445		}
 2446	}
 2447	args["before"] = arg1
 2448	var arg2 *int
 2449	if tmp, ok := rawArgs["first"]; ok {
 2450		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2451		if err != nil {
 2452			return nil, err
 2453		}
 2454	}
 2455	args["first"] = arg2
 2456	var arg3 *int
 2457	if tmp, ok := rawArgs["last"]; ok {
 2458		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2459		if err != nil {
 2460			return nil, err
 2461		}
 2462	}
 2463	args["last"] = arg3
 2464	return args, nil
 2465}
 2466
 2467func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2468	var err error
 2469	args := map[string]interface{}{}
 2470	var arg0 *string
 2471	if tmp, ok := rawArgs["after"]; ok {
 2472		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2473		if err != nil {
 2474			return nil, err
 2475		}
 2476	}
 2477	args["after"] = arg0
 2478	var arg1 *string
 2479	if tmp, ok := rawArgs["before"]; ok {
 2480		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2481		if err != nil {
 2482			return nil, err
 2483		}
 2484	}
 2485	args["before"] = arg1
 2486	var arg2 *int
 2487	if tmp, ok := rawArgs["first"]; ok {
 2488		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2489		if err != nil {
 2490			return nil, err
 2491		}
 2492	}
 2493	args["first"] = arg2
 2494	var arg3 *int
 2495	if tmp, ok := rawArgs["last"]; ok {
 2496		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2497		if err != nil {
 2498			return nil, err
 2499		}
 2500	}
 2501	args["last"] = arg3
 2502	return args, nil
 2503}
 2504
 2505func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2506	var err error
 2507	args := map[string]interface{}{}
 2508	var arg0 *string
 2509	if tmp, ok := rawArgs["after"]; ok {
 2510		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2511		if err != nil {
 2512			return nil, err
 2513		}
 2514	}
 2515	args["after"] = arg0
 2516	var arg1 *string
 2517	if tmp, ok := rawArgs["before"]; ok {
 2518		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2519		if err != nil {
 2520			return nil, err
 2521		}
 2522	}
 2523	args["before"] = arg1
 2524	var arg2 *int
 2525	if tmp, ok := rawArgs["first"]; ok {
 2526		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2527		if err != nil {
 2528			return nil, err
 2529		}
 2530	}
 2531	args["first"] = arg2
 2532	var arg3 *int
 2533	if tmp, ok := rawArgs["last"]; ok {
 2534		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2535		if err != nil {
 2536			return nil, err
 2537		}
 2538	}
 2539	args["last"] = arg3
 2540	return args, nil
 2541}
 2542
 2543func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2544	var err error
 2545	args := map[string]interface{}{}
 2546	var arg0 *string
 2547	if tmp, ok := rawArgs["after"]; ok {
 2548		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2549		if err != nil {
 2550			return nil, err
 2551		}
 2552	}
 2553	args["after"] = arg0
 2554	var arg1 *string
 2555	if tmp, ok := rawArgs["before"]; ok {
 2556		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2557		if err != nil {
 2558			return nil, err
 2559		}
 2560	}
 2561	args["before"] = arg1
 2562	var arg2 *int
 2563	if tmp, ok := rawArgs["first"]; ok {
 2564		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2565		if err != nil {
 2566			return nil, err
 2567		}
 2568	}
 2569	args["first"] = arg2
 2570	var arg3 *int
 2571	if tmp, ok := rawArgs["last"]; ok {
 2572		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2573		if err != nil {
 2574			return nil, err
 2575		}
 2576	}
 2577	args["last"] = arg3
 2578	return args, nil
 2579}
 2580
 2581func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2582	var err error
 2583	args := map[string]interface{}{}
 2584	var arg0 *string
 2585	if tmp, ok := rawArgs["after"]; ok {
 2586		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2587		if err != nil {
 2588			return nil, err
 2589		}
 2590	}
 2591	args["after"] = arg0
 2592	var arg1 *string
 2593	if tmp, ok := rawArgs["before"]; ok {
 2594		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2595		if err != nil {
 2596			return nil, err
 2597		}
 2598	}
 2599	args["before"] = arg1
 2600	var arg2 *int
 2601	if tmp, ok := rawArgs["first"]; ok {
 2602		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2603		if err != nil {
 2604			return nil, err
 2605		}
 2606	}
 2607	args["first"] = arg2
 2608	var arg3 *int
 2609	if tmp, ok := rawArgs["last"]; ok {
 2610		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2611		if err != nil {
 2612			return nil, err
 2613		}
 2614	}
 2615	args["last"] = arg3
 2616	return args, nil
 2617}
 2618
 2619func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2620	var err error
 2621	args := map[string]interface{}{}
 2622	var arg0 models.AddCommentInput
 2623	if tmp, ok := rawArgs["input"]; ok {
 2624		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2625		if err != nil {
 2626			return nil, err
 2627		}
 2628	}
 2629	args["input"] = arg0
 2630	return args, nil
 2631}
 2632
 2633func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2634	var err error
 2635	args := map[string]interface{}{}
 2636	var arg0 *models.ChangeLabelInput
 2637	if tmp, ok := rawArgs["input"]; ok {
 2638		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2639		if err != nil {
 2640			return nil, err
 2641		}
 2642	}
 2643	args["input"] = arg0
 2644	return args, nil
 2645}
 2646
 2647func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2648	var err error
 2649	args := map[string]interface{}{}
 2650	var arg0 models.CloseBugInput
 2651	if tmp, ok := rawArgs["input"]; ok {
 2652		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2653		if err != nil {
 2654			return nil, err
 2655		}
 2656	}
 2657	args["input"] = arg0
 2658	return args, nil
 2659}
 2660
 2661func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2662	var err error
 2663	args := map[string]interface{}{}
 2664	var arg0 models.NewBugInput
 2665	if tmp, ok := rawArgs["input"]; ok {
 2666		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2667		if err != nil {
 2668			return nil, err
 2669		}
 2670	}
 2671	args["input"] = arg0
 2672	return args, nil
 2673}
 2674
 2675func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2676	var err error
 2677	args := map[string]interface{}{}
 2678	var arg0 models.OpenBugInput
 2679	if tmp, ok := rawArgs["input"]; ok {
 2680		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2681		if err != nil {
 2682			return nil, err
 2683		}
 2684	}
 2685	args["input"] = arg0
 2686	return args, nil
 2687}
 2688
 2689func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2690	var err error
 2691	args := map[string]interface{}{}
 2692	var arg0 models.SetTitleInput
 2693	if tmp, ok := rawArgs["input"]; ok {
 2694		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2695		if err != nil {
 2696			return nil, err
 2697		}
 2698	}
 2699	args["input"] = arg0
 2700	return args, nil
 2701}
 2702
 2703func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2704	var err error
 2705	args := map[string]interface{}{}
 2706	var arg0 string
 2707	if tmp, ok := rawArgs["name"]; ok {
 2708		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2709		if err != nil {
 2710			return nil, err
 2711		}
 2712	}
 2713	args["name"] = arg0
 2714	return args, nil
 2715}
 2716
 2717func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2718	var err error
 2719	args := map[string]interface{}{}
 2720	var arg0 *string
 2721	if tmp, ok := rawArgs["ref"]; ok {
 2722		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2723		if err != nil {
 2724			return nil, err
 2725		}
 2726	}
 2727	args["ref"] = arg0
 2728	return args, nil
 2729}
 2730
 2731func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2732	var err error
 2733	args := map[string]interface{}{}
 2734	var arg0 *string
 2735	if tmp, ok := rawArgs["after"]; ok {
 2736		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2737		if err != nil {
 2738			return nil, err
 2739		}
 2740	}
 2741	args["after"] = arg0
 2742	var arg1 *string
 2743	if tmp, ok := rawArgs["before"]; ok {
 2744		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2745		if err != nil {
 2746			return nil, err
 2747		}
 2748	}
 2749	args["before"] = arg1
 2750	var arg2 *int
 2751	if tmp, ok := rawArgs["first"]; ok {
 2752		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2753		if err != nil {
 2754			return nil, err
 2755		}
 2756	}
 2757	args["first"] = arg2
 2758	var arg3 *int
 2759	if tmp, ok := rawArgs["last"]; ok {
 2760		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2761		if err != nil {
 2762			return nil, err
 2763		}
 2764	}
 2765	args["last"] = arg3
 2766	var arg4 *string
 2767	if tmp, ok := rawArgs["query"]; ok {
 2768		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2769		if err != nil {
 2770			return nil, err
 2771		}
 2772	}
 2773	args["query"] = arg4
 2774	return args, nil
 2775}
 2776
 2777func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2778	var err error
 2779	args := map[string]interface{}{}
 2780	var arg0 *string
 2781	if tmp, ok := rawArgs["after"]; ok {
 2782		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2783		if err != nil {
 2784			return nil, err
 2785		}
 2786	}
 2787	args["after"] = arg0
 2788	var arg1 *string
 2789	if tmp, ok := rawArgs["before"]; ok {
 2790		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2791		if err != nil {
 2792			return nil, err
 2793		}
 2794	}
 2795	args["before"] = arg1
 2796	var arg2 *int
 2797	if tmp, ok := rawArgs["first"]; ok {
 2798		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2799		if err != nil {
 2800			return nil, err
 2801		}
 2802	}
 2803	args["first"] = arg2
 2804	var arg3 *int
 2805	if tmp, ok := rawArgs["last"]; ok {
 2806		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2807		if err != nil {
 2808			return nil, err
 2809		}
 2810	}
 2811	args["last"] = arg3
 2812	return args, nil
 2813}
 2814
 2815func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2816	var err error
 2817	args := map[string]interface{}{}
 2818	var arg0 string
 2819	if tmp, ok := rawArgs["prefix"]; ok {
 2820		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2821		if err != nil {
 2822			return nil, err
 2823		}
 2824	}
 2825	args["prefix"] = arg0
 2826	return args, nil
 2827}
 2828
 2829func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2830	var err error
 2831	args := map[string]interface{}{}
 2832	var arg0 string
 2833	if tmp, ok := rawArgs["prefix"]; ok {
 2834		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2835		if err != nil {
 2836			return nil, err
 2837		}
 2838	}
 2839	args["prefix"] = arg0
 2840	return args, nil
 2841}
 2842
 2843func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2844	var err error
 2845	args := map[string]interface{}{}
 2846	var arg0 *string
 2847	if tmp, ok := rawArgs["after"]; ok {
 2848		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2849		if err != nil {
 2850			return nil, err
 2851		}
 2852	}
 2853	args["after"] = arg0
 2854	var arg1 *string
 2855	if tmp, ok := rawArgs["before"]; ok {
 2856		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2857		if err != nil {
 2858			return nil, err
 2859		}
 2860	}
 2861	args["before"] = arg1
 2862	var arg2 *int
 2863	if tmp, ok := rawArgs["first"]; ok {
 2864		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2865		if err != nil {
 2866			return nil, err
 2867		}
 2868	}
 2869	args["first"] = arg2
 2870	var arg3 *int
 2871	if tmp, ok := rawArgs["last"]; ok {
 2872		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2873		if err != nil {
 2874			return nil, err
 2875		}
 2876	}
 2877	args["last"] = arg3
 2878	return args, nil
 2879}
 2880
 2881func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2882	var err error
 2883	args := map[string]interface{}{}
 2884	var arg0 bool
 2885	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2886		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2887		if err != nil {
 2888			return nil, err
 2889		}
 2890	}
 2891	args["includeDeprecated"] = arg0
 2892	return args, nil
 2893}
 2894
 2895func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2896	var err error
 2897	args := map[string]interface{}{}
 2898	var arg0 bool
 2899	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2900		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2901		if err != nil {
 2902			return nil, err
 2903		}
 2904	}
 2905	args["includeDeprecated"] = arg0
 2906	return args, nil
 2907}
 2908
 2909// endregion ***************************** args.gotpl *****************************
 2910
 2911// region    ************************** directives.gotpl **************************
 2912
 2913// endregion ************************** directives.gotpl **************************
 2914
 2915// region    **************************** field.gotpl *****************************
 2916
 2917func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2918	defer func() {
 2919		if r := recover(); r != nil {
 2920			ec.Error(ctx, ec.Recover(ctx, r))
 2921			ret = graphql.Null
 2922		}
 2923	}()
 2924	fc := &graphql.FieldContext{
 2925		Object:   "AddCommentOperation",
 2926		Field:    field,
 2927		Args:     nil,
 2928		IsMethod: true,
 2929	}
 2930
 2931	ctx = graphql.WithFieldContext(ctx, fc)
 2932	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2933		ctx = rctx // use context from middleware stack in children
 2934		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 2935	})
 2936	if err != nil {
 2937		ec.Error(ctx, err)
 2938		return graphql.Null
 2939	}
 2940	if resTmp == nil {
 2941		if !graphql.HasFieldError(ctx, fc) {
 2942			ec.Errorf(ctx, "must not be null")
 2943		}
 2944		return graphql.Null
 2945	}
 2946	res := resTmp.(string)
 2947	fc.Result = res
 2948	return ec.marshalNString2string(ctx, field.Selections, res)
 2949}
 2950
 2951func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2952	defer func() {
 2953		if r := recover(); r != nil {
 2954			ec.Error(ctx, ec.Recover(ctx, r))
 2955			ret = graphql.Null
 2956		}
 2957	}()
 2958	fc := &graphql.FieldContext{
 2959		Object:   "AddCommentOperation",
 2960		Field:    field,
 2961		Args:     nil,
 2962		IsMethod: true,
 2963	}
 2964
 2965	ctx = graphql.WithFieldContext(ctx, fc)
 2966	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2967		ctx = rctx // use context from middleware stack in children
 2968		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
 2969	})
 2970	if err != nil {
 2971		ec.Error(ctx, err)
 2972		return graphql.Null
 2973	}
 2974	if resTmp == nil {
 2975		if !graphql.HasFieldError(ctx, fc) {
 2976			ec.Errorf(ctx, "must not be null")
 2977		}
 2978		return graphql.Null
 2979	}
 2980	res := resTmp.(models.IdentityWrapper)
 2981	fc.Result = res
 2982	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 2983}
 2984
 2985func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2986	defer func() {
 2987		if r := recover(); r != nil {
 2988			ec.Error(ctx, ec.Recover(ctx, r))
 2989			ret = graphql.Null
 2990		}
 2991	}()
 2992	fc := &graphql.FieldContext{
 2993		Object:   "AddCommentOperation",
 2994		Field:    field,
 2995		Args:     nil,
 2996		IsMethod: true,
 2997	}
 2998
 2999	ctx = graphql.WithFieldContext(ctx, fc)
 3000	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3001		ctx = rctx // use context from middleware stack in children
 3002		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 3003	})
 3004	if err != nil {
 3005		ec.Error(ctx, err)
 3006		return graphql.Null
 3007	}
 3008	if resTmp == nil {
 3009		if !graphql.HasFieldError(ctx, fc) {
 3010			ec.Errorf(ctx, "must not be null")
 3011		}
 3012		return graphql.Null
 3013	}
 3014	res := resTmp.(*time.Time)
 3015	fc.Result = res
 3016	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3017}
 3018
 3019func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3020	defer func() {
 3021		if r := recover(); r != nil {
 3022			ec.Error(ctx, ec.Recover(ctx, r))
 3023			ret = graphql.Null
 3024		}
 3025	}()
 3026	fc := &graphql.FieldContext{
 3027		Object:   "AddCommentOperation",
 3028		Field:    field,
 3029		Args:     nil,
 3030		IsMethod: false,
 3031	}
 3032
 3033	ctx = graphql.WithFieldContext(ctx, fc)
 3034	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3035		ctx = rctx // use context from middleware stack in children
 3036		return obj.Message, nil
 3037	})
 3038	if err != nil {
 3039		ec.Error(ctx, err)
 3040		return graphql.Null
 3041	}
 3042	if resTmp == nil {
 3043		if !graphql.HasFieldError(ctx, fc) {
 3044			ec.Errorf(ctx, "must not be null")
 3045		}
 3046		return graphql.Null
 3047	}
 3048	res := resTmp.(string)
 3049	fc.Result = res
 3050	return ec.marshalNString2string(ctx, field.Selections, res)
 3051}
 3052
 3053func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3054	defer func() {
 3055		if r := recover(); r != nil {
 3056			ec.Error(ctx, ec.Recover(ctx, r))
 3057			ret = graphql.Null
 3058		}
 3059	}()
 3060	fc := &graphql.FieldContext{
 3061		Object:   "AddCommentOperation",
 3062		Field:    field,
 3063		Args:     nil,
 3064		IsMethod: false,
 3065	}
 3066
 3067	ctx = graphql.WithFieldContext(ctx, fc)
 3068	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3069		ctx = rctx // use context from middleware stack in children
 3070		return obj.Files, nil
 3071	})
 3072	if err != nil {
 3073		ec.Error(ctx, err)
 3074		return graphql.Null
 3075	}
 3076	if resTmp == nil {
 3077		if !graphql.HasFieldError(ctx, fc) {
 3078			ec.Errorf(ctx, "must not be null")
 3079		}
 3080		return graphql.Null
 3081	}
 3082	res := resTmp.([]git.Hash)
 3083	fc.Result = res
 3084	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3085}
 3086
 3087func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3088	defer func() {
 3089		if r := recover(); r != nil {
 3090			ec.Error(ctx, ec.Recover(ctx, r))
 3091			ret = graphql.Null
 3092		}
 3093	}()
 3094	fc := &graphql.FieldContext{
 3095		Object:   "AddCommentPayload",
 3096		Field:    field,
 3097		Args:     nil,
 3098		IsMethod: false,
 3099	}
 3100
 3101	ctx = graphql.WithFieldContext(ctx, fc)
 3102	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3103		ctx = rctx // use context from middleware stack in children
 3104		return obj.ClientMutationID, nil
 3105	})
 3106	if err != nil {
 3107		ec.Error(ctx, err)
 3108		return graphql.Null
 3109	}
 3110	if resTmp == nil {
 3111		return graphql.Null
 3112	}
 3113	res := resTmp.(*string)
 3114	fc.Result = res
 3115	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3116}
 3117
 3118func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3119	defer func() {
 3120		if r := recover(); r != nil {
 3121			ec.Error(ctx, ec.Recover(ctx, r))
 3122			ret = graphql.Null
 3123		}
 3124	}()
 3125	fc := &graphql.FieldContext{
 3126		Object:   "AddCommentPayload",
 3127		Field:    field,
 3128		Args:     nil,
 3129		IsMethod: false,
 3130	}
 3131
 3132	ctx = graphql.WithFieldContext(ctx, fc)
 3133	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3134		ctx = rctx // use context from middleware stack in children
 3135		return obj.Bug, nil
 3136	})
 3137	if err != nil {
 3138		ec.Error(ctx, err)
 3139		return graphql.Null
 3140	}
 3141	if resTmp == nil {
 3142		if !graphql.HasFieldError(ctx, fc) {
 3143			ec.Errorf(ctx, "must not be null")
 3144		}
 3145		return graphql.Null
 3146	}
 3147	res := resTmp.(models.BugWrapper)
 3148	fc.Result = res
 3149	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 3150}
 3151
 3152func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3153	defer func() {
 3154		if r := recover(); r != nil {
 3155			ec.Error(ctx, ec.Recover(ctx, r))
 3156			ret = graphql.Null
 3157		}
 3158	}()
 3159	fc := &graphql.FieldContext{
 3160		Object:   "AddCommentPayload",
 3161		Field:    field,
 3162		Args:     nil,
 3163		IsMethod: false,
 3164	}
 3165
 3166	ctx = graphql.WithFieldContext(ctx, fc)
 3167	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3168		ctx = rctx // use context from middleware stack in children
 3169		return obj.Operation, nil
 3170	})
 3171	if err != nil {
 3172		ec.Error(ctx, err)
 3173		return graphql.Null
 3174	}
 3175	if resTmp == nil {
 3176		if !graphql.HasFieldError(ctx, fc) {
 3177			ec.Errorf(ctx, "must not be null")
 3178		}
 3179		return graphql.Null
 3180	}
 3181	res := resTmp.(*bug.AddCommentOperation)
 3182	fc.Result = res
 3183	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3184}
 3185
 3186func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3187	defer func() {
 3188		if r := recover(); r != nil {
 3189			ec.Error(ctx, ec.Recover(ctx, r))
 3190			ret = graphql.Null
 3191		}
 3192	}()
 3193	fc := &graphql.FieldContext{
 3194		Object:   "AddCommentTimelineItem",
 3195		Field:    field,
 3196		Args:     nil,
 3197		IsMethod: true,
 3198	}
 3199
 3200	ctx = graphql.WithFieldContext(ctx, fc)
 3201	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3202		ctx = rctx // use context from middleware stack in children
 3203		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3204	})
 3205	if err != nil {
 3206		ec.Error(ctx, err)
 3207		return graphql.Null
 3208	}
 3209	if resTmp == nil {
 3210		if !graphql.HasFieldError(ctx, fc) {
 3211			ec.Errorf(ctx, "must not be null")
 3212		}
 3213		return graphql.Null
 3214	}
 3215	res := resTmp.(string)
 3216	fc.Result = res
 3217	return ec.marshalNString2string(ctx, field.Selections, res)
 3218}
 3219
 3220func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3221	defer func() {
 3222		if r := recover(); r != nil {
 3223			ec.Error(ctx, ec.Recover(ctx, r))
 3224			ret = graphql.Null
 3225		}
 3226	}()
 3227	fc := &graphql.FieldContext{
 3228		Object:   "AddCommentTimelineItem",
 3229		Field:    field,
 3230		Args:     nil,
 3231		IsMethod: true,
 3232	}
 3233
 3234	ctx = graphql.WithFieldContext(ctx, fc)
 3235	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3236		ctx = rctx // use context from middleware stack in children
 3237		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
 3238	})
 3239	if err != nil {
 3240		ec.Error(ctx, err)
 3241		return graphql.Null
 3242	}
 3243	if resTmp == nil {
 3244		if !graphql.HasFieldError(ctx, fc) {
 3245			ec.Errorf(ctx, "must not be null")
 3246		}
 3247		return graphql.Null
 3248	}
 3249	res := resTmp.(models.IdentityWrapper)
 3250	fc.Result = res
 3251	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3252}
 3253
 3254func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3255	defer func() {
 3256		if r := recover(); r != nil {
 3257			ec.Error(ctx, ec.Recover(ctx, r))
 3258			ret = graphql.Null
 3259		}
 3260	}()
 3261	fc := &graphql.FieldContext{
 3262		Object:   "AddCommentTimelineItem",
 3263		Field:    field,
 3264		Args:     nil,
 3265		IsMethod: false,
 3266	}
 3267
 3268	ctx = graphql.WithFieldContext(ctx, fc)
 3269	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3270		ctx = rctx // use context from middleware stack in children
 3271		return obj.Message, nil
 3272	})
 3273	if err != nil {
 3274		ec.Error(ctx, err)
 3275		return graphql.Null
 3276	}
 3277	if resTmp == nil {
 3278		if !graphql.HasFieldError(ctx, fc) {
 3279			ec.Errorf(ctx, "must not be null")
 3280		}
 3281		return graphql.Null
 3282	}
 3283	res := resTmp.(string)
 3284	fc.Result = res
 3285	return ec.marshalNString2string(ctx, field.Selections, res)
 3286}
 3287
 3288func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3289	defer func() {
 3290		if r := recover(); r != nil {
 3291			ec.Error(ctx, ec.Recover(ctx, r))
 3292			ret = graphql.Null
 3293		}
 3294	}()
 3295	fc := &graphql.FieldContext{
 3296		Object:   "AddCommentTimelineItem",
 3297		Field:    field,
 3298		Args:     nil,
 3299		IsMethod: true,
 3300	}
 3301
 3302	ctx = graphql.WithFieldContext(ctx, fc)
 3303	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3304		ctx = rctx // use context from middleware stack in children
 3305		return obj.MessageIsEmpty(), nil
 3306	})
 3307	if err != nil {
 3308		ec.Error(ctx, err)
 3309		return graphql.Null
 3310	}
 3311	if resTmp == nil {
 3312		if !graphql.HasFieldError(ctx, fc) {
 3313			ec.Errorf(ctx, "must not be null")
 3314		}
 3315		return graphql.Null
 3316	}
 3317	res := resTmp.(bool)
 3318	fc.Result = res
 3319	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3320}
 3321
 3322func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3323	defer func() {
 3324		if r := recover(); r != nil {
 3325			ec.Error(ctx, ec.Recover(ctx, r))
 3326			ret = graphql.Null
 3327		}
 3328	}()
 3329	fc := &graphql.FieldContext{
 3330		Object:   "AddCommentTimelineItem",
 3331		Field:    field,
 3332		Args:     nil,
 3333		IsMethod: false,
 3334	}
 3335
 3336	ctx = graphql.WithFieldContext(ctx, fc)
 3337	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3338		ctx = rctx // use context from middleware stack in children
 3339		return obj.Files, nil
 3340	})
 3341	if err != nil {
 3342		ec.Error(ctx, err)
 3343		return graphql.Null
 3344	}
 3345	if resTmp == nil {
 3346		if !graphql.HasFieldError(ctx, fc) {
 3347			ec.Errorf(ctx, "must not be null")
 3348		}
 3349		return graphql.Null
 3350	}
 3351	res := resTmp.([]git.Hash)
 3352	fc.Result = res
 3353	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3354}
 3355
 3356func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3357	defer func() {
 3358		if r := recover(); r != nil {
 3359			ec.Error(ctx, ec.Recover(ctx, r))
 3360			ret = graphql.Null
 3361		}
 3362	}()
 3363	fc := &graphql.FieldContext{
 3364		Object:   "AddCommentTimelineItem",
 3365		Field:    field,
 3366		Args:     nil,
 3367		IsMethod: true,
 3368	}
 3369
 3370	ctx = graphql.WithFieldContext(ctx, fc)
 3371	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3372		ctx = rctx // use context from middleware stack in children
 3373		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3374	})
 3375	if err != nil {
 3376		ec.Error(ctx, err)
 3377		return graphql.Null
 3378	}
 3379	if resTmp == nil {
 3380		if !graphql.HasFieldError(ctx, fc) {
 3381			ec.Errorf(ctx, "must not be null")
 3382		}
 3383		return graphql.Null
 3384	}
 3385	res := resTmp.(*time.Time)
 3386	fc.Result = res
 3387	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3388}
 3389
 3390func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3391	defer func() {
 3392		if r := recover(); r != nil {
 3393			ec.Error(ctx, ec.Recover(ctx, r))
 3394			ret = graphql.Null
 3395		}
 3396	}()
 3397	fc := &graphql.FieldContext{
 3398		Object:   "AddCommentTimelineItem",
 3399		Field:    field,
 3400		Args:     nil,
 3401		IsMethod: true,
 3402	}
 3403
 3404	ctx = graphql.WithFieldContext(ctx, fc)
 3405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3406		ctx = rctx // use context from middleware stack in children
 3407		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3408	})
 3409	if err != nil {
 3410		ec.Error(ctx, err)
 3411		return graphql.Null
 3412	}
 3413	if resTmp == nil {
 3414		if !graphql.HasFieldError(ctx, fc) {
 3415			ec.Errorf(ctx, "must not be null")
 3416		}
 3417		return graphql.Null
 3418	}
 3419	res := resTmp.(*time.Time)
 3420	fc.Result = res
 3421	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3422}
 3423
 3424func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3425	defer func() {
 3426		if r := recover(); r != nil {
 3427			ec.Error(ctx, ec.Recover(ctx, r))
 3428			ret = graphql.Null
 3429		}
 3430	}()
 3431	fc := &graphql.FieldContext{
 3432		Object:   "AddCommentTimelineItem",
 3433		Field:    field,
 3434		Args:     nil,
 3435		IsMethod: true,
 3436	}
 3437
 3438	ctx = graphql.WithFieldContext(ctx, fc)
 3439	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3440		ctx = rctx // use context from middleware stack in children
 3441		return obj.Edited(), nil
 3442	})
 3443	if err != nil {
 3444		ec.Error(ctx, err)
 3445		return graphql.Null
 3446	}
 3447	if resTmp == nil {
 3448		if !graphql.HasFieldError(ctx, fc) {
 3449			ec.Errorf(ctx, "must not be null")
 3450		}
 3451		return graphql.Null
 3452	}
 3453	res := resTmp.(bool)
 3454	fc.Result = res
 3455	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3456}
 3457
 3458func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3459	defer func() {
 3460		if r := recover(); r != nil {
 3461			ec.Error(ctx, ec.Recover(ctx, r))
 3462			ret = graphql.Null
 3463		}
 3464	}()
 3465	fc := &graphql.FieldContext{
 3466		Object:   "AddCommentTimelineItem",
 3467		Field:    field,
 3468		Args:     nil,
 3469		IsMethod: false,
 3470	}
 3471
 3472	ctx = graphql.WithFieldContext(ctx, fc)
 3473	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3474		ctx = rctx // use context from middleware stack in children
 3475		return obj.History, nil
 3476	})
 3477	if err != nil {
 3478		ec.Error(ctx, err)
 3479		return graphql.Null
 3480	}
 3481	if resTmp == nil {
 3482		if !graphql.HasFieldError(ctx, fc) {
 3483			ec.Errorf(ctx, "must not be null")
 3484		}
 3485		return graphql.Null
 3486	}
 3487	res := resTmp.([]bug.CommentHistoryStep)
 3488	fc.Result = res
 3489	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3490}
 3491
 3492func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3493	defer func() {
 3494		if r := recover(); r != nil {
 3495			ec.Error(ctx, ec.Recover(ctx, r))
 3496			ret = graphql.Null
 3497		}
 3498	}()
 3499	fc := &graphql.FieldContext{
 3500		Object:   "Bug",
 3501		Field:    field,
 3502		Args:     nil,
 3503		IsMethod: true,
 3504	}
 3505
 3506	ctx = graphql.WithFieldContext(ctx, fc)
 3507	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3508		ctx = rctx // use context from middleware stack in children
 3509		return ec.resolvers.Bug().ID(rctx, obj)
 3510	})
 3511	if err != nil {
 3512		ec.Error(ctx, err)
 3513		return graphql.Null
 3514	}
 3515	if resTmp == nil {
 3516		if !graphql.HasFieldError(ctx, fc) {
 3517			ec.Errorf(ctx, "must not be null")
 3518		}
 3519		return graphql.Null
 3520	}
 3521	res := resTmp.(string)
 3522	fc.Result = res
 3523	return ec.marshalNString2string(ctx, field.Selections, res)
 3524}
 3525
 3526func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3527	defer func() {
 3528		if r := recover(); r != nil {
 3529			ec.Error(ctx, ec.Recover(ctx, r))
 3530			ret = graphql.Null
 3531		}
 3532	}()
 3533	fc := &graphql.FieldContext{
 3534		Object:   "Bug",
 3535		Field:    field,
 3536		Args:     nil,
 3537		IsMethod: true,
 3538	}
 3539
 3540	ctx = graphql.WithFieldContext(ctx, fc)
 3541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3542		ctx = rctx // use context from middleware stack in children
 3543		return ec.resolvers.Bug().HumanID(rctx, obj)
 3544	})
 3545	if err != nil {
 3546		ec.Error(ctx, err)
 3547		return graphql.Null
 3548	}
 3549	if resTmp == nil {
 3550		if !graphql.HasFieldError(ctx, fc) {
 3551			ec.Errorf(ctx, "must not be null")
 3552		}
 3553		return graphql.Null
 3554	}
 3555	res := resTmp.(string)
 3556	fc.Result = res
 3557	return ec.marshalNString2string(ctx, field.Selections, res)
 3558}
 3559
 3560func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3561	defer func() {
 3562		if r := recover(); r != nil {
 3563			ec.Error(ctx, ec.Recover(ctx, r))
 3564			ret = graphql.Null
 3565		}
 3566	}()
 3567	fc := &graphql.FieldContext{
 3568		Object:   "Bug",
 3569		Field:    field,
 3570		Args:     nil,
 3571		IsMethod: true,
 3572	}
 3573
 3574	ctx = graphql.WithFieldContext(ctx, fc)
 3575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3576		ctx = rctx // use context from middleware stack in children
 3577		return ec.resolvers.Bug().Status(rctx, obj)
 3578	})
 3579	if err != nil {
 3580		ec.Error(ctx, err)
 3581		return graphql.Null
 3582	}
 3583	if resTmp == nil {
 3584		if !graphql.HasFieldError(ctx, fc) {
 3585			ec.Errorf(ctx, "must not be null")
 3586		}
 3587		return graphql.Null
 3588	}
 3589	res := resTmp.(models.Status)
 3590	fc.Result = res
 3591	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3592}
 3593
 3594func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3595	defer func() {
 3596		if r := recover(); r != nil {
 3597			ec.Error(ctx, ec.Recover(ctx, r))
 3598			ret = graphql.Null
 3599		}
 3600	}()
 3601	fc := &graphql.FieldContext{
 3602		Object:   "Bug",
 3603		Field:    field,
 3604		Args:     nil,
 3605		IsMethod: true,
 3606	}
 3607
 3608	ctx = graphql.WithFieldContext(ctx, fc)
 3609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3610		ctx = rctx // use context from middleware stack in children
 3611		return obj.Title(), nil
 3612	})
 3613	if err != nil {
 3614		ec.Error(ctx, err)
 3615		return graphql.Null
 3616	}
 3617	if resTmp == nil {
 3618		if !graphql.HasFieldError(ctx, fc) {
 3619			ec.Errorf(ctx, "must not be null")
 3620		}
 3621		return graphql.Null
 3622	}
 3623	res := resTmp.(string)
 3624	fc.Result = res
 3625	return ec.marshalNString2string(ctx, field.Selections, res)
 3626}
 3627
 3628func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3629	defer func() {
 3630		if r := recover(); r != nil {
 3631			ec.Error(ctx, ec.Recover(ctx, r))
 3632			ret = graphql.Null
 3633		}
 3634	}()
 3635	fc := &graphql.FieldContext{
 3636		Object:   "Bug",
 3637		Field:    field,
 3638		Args:     nil,
 3639		IsMethod: true,
 3640	}
 3641
 3642	ctx = graphql.WithFieldContext(ctx, fc)
 3643	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3644		ctx = rctx // use context from middleware stack in children
 3645		return obj.Labels(), nil
 3646	})
 3647	if err != nil {
 3648		ec.Error(ctx, err)
 3649		return graphql.Null
 3650	}
 3651	if resTmp == nil {
 3652		if !graphql.HasFieldError(ctx, fc) {
 3653			ec.Errorf(ctx, "must not be null")
 3654		}
 3655		return graphql.Null
 3656	}
 3657	res := resTmp.([]bug.Label)
 3658	fc.Result = res
 3659	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 3660}
 3661
 3662func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3663	defer func() {
 3664		if r := recover(); r != nil {
 3665			ec.Error(ctx, ec.Recover(ctx, r))
 3666			ret = graphql.Null
 3667		}
 3668	}()
 3669	fc := &graphql.FieldContext{
 3670		Object:   "Bug",
 3671		Field:    field,
 3672		Args:     nil,
 3673		IsMethod: true,
 3674	}
 3675
 3676	ctx = graphql.WithFieldContext(ctx, fc)
 3677	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3678		ctx = rctx // use context from middleware stack in children
 3679		return obj.Author()
 3680	})
 3681	if err != nil {
 3682		ec.Error(ctx, err)
 3683		return graphql.Null
 3684	}
 3685	if resTmp == nil {
 3686		if !graphql.HasFieldError(ctx, fc) {
 3687			ec.Errorf(ctx, "must not be null")
 3688		}
 3689		return graphql.Null
 3690	}
 3691	res := resTmp.(models.IdentityWrapper)
 3692	fc.Result = res
 3693	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3694}
 3695
 3696func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3697	defer func() {
 3698		if r := recover(); r != nil {
 3699			ec.Error(ctx, ec.Recover(ctx, r))
 3700			ret = graphql.Null
 3701		}
 3702	}()
 3703	fc := &graphql.FieldContext{
 3704		Object:   "Bug",
 3705		Field:    field,
 3706		Args:     nil,
 3707		IsMethod: true,
 3708	}
 3709
 3710	ctx = graphql.WithFieldContext(ctx, fc)
 3711	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3712		ctx = rctx // use context from middleware stack in children
 3713		return obj.CreatedAt(), nil
 3714	})
 3715	if err != nil {
 3716		ec.Error(ctx, err)
 3717		return graphql.Null
 3718	}
 3719	if resTmp == nil {
 3720		if !graphql.HasFieldError(ctx, fc) {
 3721			ec.Errorf(ctx, "must not be null")
 3722		}
 3723		return graphql.Null
 3724	}
 3725	res := resTmp.(time.Time)
 3726	fc.Result = res
 3727	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3728}
 3729
 3730func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3731	defer func() {
 3732		if r := recover(); r != nil {
 3733			ec.Error(ctx, ec.Recover(ctx, r))
 3734			ret = graphql.Null
 3735		}
 3736	}()
 3737	fc := &graphql.FieldContext{
 3738		Object:   "Bug",
 3739		Field:    field,
 3740		Args:     nil,
 3741		IsMethod: true,
 3742	}
 3743
 3744	ctx = graphql.WithFieldContext(ctx, fc)
 3745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3746		ctx = rctx // use context from middleware stack in children
 3747		return obj.LastEdit(), nil
 3748	})
 3749	if err != nil {
 3750		ec.Error(ctx, err)
 3751		return graphql.Null
 3752	}
 3753	if resTmp == nil {
 3754		if !graphql.HasFieldError(ctx, fc) {
 3755			ec.Errorf(ctx, "must not be null")
 3756		}
 3757		return graphql.Null
 3758	}
 3759	res := resTmp.(time.Time)
 3760	fc.Result = res
 3761	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3762}
 3763
 3764func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3765	defer func() {
 3766		if r := recover(); r != nil {
 3767			ec.Error(ctx, ec.Recover(ctx, r))
 3768			ret = graphql.Null
 3769		}
 3770	}()
 3771	fc := &graphql.FieldContext{
 3772		Object:   "Bug",
 3773		Field:    field,
 3774		Args:     nil,
 3775		IsMethod: true,
 3776	}
 3777
 3778	ctx = graphql.WithFieldContext(ctx, fc)
 3779	rawArgs := field.ArgumentMap(ec.Variables)
 3780	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3781	if err != nil {
 3782		ec.Error(ctx, err)
 3783		return graphql.Null
 3784	}
 3785	fc.Args = args
 3786	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3787		ctx = rctx // use context from middleware stack in children
 3788		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3789	})
 3790	if err != nil {
 3791		ec.Error(ctx, err)
 3792		return graphql.Null
 3793	}
 3794	if resTmp == nil {
 3795		if !graphql.HasFieldError(ctx, fc) {
 3796			ec.Errorf(ctx, "must not be null")
 3797		}
 3798		return graphql.Null
 3799	}
 3800	res := resTmp.(*models.IdentityConnection)
 3801	fc.Result = res
 3802	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3803}
 3804
 3805func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3806	defer func() {
 3807		if r := recover(); r != nil {
 3808			ec.Error(ctx, ec.Recover(ctx, r))
 3809			ret = graphql.Null
 3810		}
 3811	}()
 3812	fc := &graphql.FieldContext{
 3813		Object:   "Bug",
 3814		Field:    field,
 3815		Args:     nil,
 3816		IsMethod: true,
 3817	}
 3818
 3819	ctx = graphql.WithFieldContext(ctx, fc)
 3820	rawArgs := field.ArgumentMap(ec.Variables)
 3821	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3822	if err != nil {
 3823		ec.Error(ctx, err)
 3824		return graphql.Null
 3825	}
 3826	fc.Args = args
 3827	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3828		ctx = rctx // use context from middleware stack in children
 3829		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3830	})
 3831	if err != nil {
 3832		ec.Error(ctx, err)
 3833		return graphql.Null
 3834	}
 3835	if resTmp == nil {
 3836		if !graphql.HasFieldError(ctx, fc) {
 3837			ec.Errorf(ctx, "must not be null")
 3838		}
 3839		return graphql.Null
 3840	}
 3841	res := resTmp.(*models.IdentityConnection)
 3842	fc.Result = res
 3843	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3844}
 3845
 3846func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3847	defer func() {
 3848		if r := recover(); r != nil {
 3849			ec.Error(ctx, ec.Recover(ctx, r))
 3850			ret = graphql.Null
 3851		}
 3852	}()
 3853	fc := &graphql.FieldContext{
 3854		Object:   "Bug",
 3855		Field:    field,
 3856		Args:     nil,
 3857		IsMethod: true,
 3858	}
 3859
 3860	ctx = graphql.WithFieldContext(ctx, fc)
 3861	rawArgs := field.ArgumentMap(ec.Variables)
 3862	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3863	if err != nil {
 3864		ec.Error(ctx, err)
 3865		return graphql.Null
 3866	}
 3867	fc.Args = args
 3868	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3869		ctx = rctx // use context from middleware stack in children
 3870		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3871	})
 3872	if err != nil {
 3873		ec.Error(ctx, err)
 3874		return graphql.Null
 3875	}
 3876	if resTmp == nil {
 3877		if !graphql.HasFieldError(ctx, fc) {
 3878			ec.Errorf(ctx, "must not be null")
 3879		}
 3880		return graphql.Null
 3881	}
 3882	res := resTmp.(*models.CommentConnection)
 3883	fc.Result = res
 3884	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3885}
 3886
 3887func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3888	defer func() {
 3889		if r := recover(); r != nil {
 3890			ec.Error(ctx, ec.Recover(ctx, r))
 3891			ret = graphql.Null
 3892		}
 3893	}()
 3894	fc := &graphql.FieldContext{
 3895		Object:   "Bug",
 3896		Field:    field,
 3897		Args:     nil,
 3898		IsMethod: true,
 3899	}
 3900
 3901	ctx = graphql.WithFieldContext(ctx, fc)
 3902	rawArgs := field.ArgumentMap(ec.Variables)
 3903	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3904	if err != nil {
 3905		ec.Error(ctx, err)
 3906		return graphql.Null
 3907	}
 3908	fc.Args = args
 3909	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3910		ctx = rctx // use context from middleware stack in children
 3911		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3912	})
 3913	if err != nil {
 3914		ec.Error(ctx, err)
 3915		return graphql.Null
 3916	}
 3917	if resTmp == nil {
 3918		if !graphql.HasFieldError(ctx, fc) {
 3919			ec.Errorf(ctx, "must not be null")
 3920		}
 3921		return graphql.Null
 3922	}
 3923	res := resTmp.(*models.TimelineItemConnection)
 3924	fc.Result = res
 3925	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 3926}
 3927
 3928func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3929	defer func() {
 3930		if r := recover(); r != nil {
 3931			ec.Error(ctx, ec.Recover(ctx, r))
 3932			ret = graphql.Null
 3933		}
 3934	}()
 3935	fc := &graphql.FieldContext{
 3936		Object:   "Bug",
 3937		Field:    field,
 3938		Args:     nil,
 3939		IsMethod: true,
 3940	}
 3941
 3942	ctx = graphql.WithFieldContext(ctx, fc)
 3943	rawArgs := field.ArgumentMap(ec.Variables)
 3944	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 3945	if err != nil {
 3946		ec.Error(ctx, err)
 3947		return graphql.Null
 3948	}
 3949	fc.Args = args
 3950	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3951		ctx = rctx // use context from middleware stack in children
 3952		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3953	})
 3954	if err != nil {
 3955		ec.Error(ctx, err)
 3956		return graphql.Null
 3957	}
 3958	if resTmp == nil {
 3959		if !graphql.HasFieldError(ctx, fc) {
 3960			ec.Errorf(ctx, "must not be null")
 3961		}
 3962		return graphql.Null
 3963	}
 3964	res := resTmp.(*models.OperationConnection)
 3965	fc.Result = res
 3966	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 3967}
 3968
 3969func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 3970	defer func() {
 3971		if r := recover(); r != nil {
 3972			ec.Error(ctx, ec.Recover(ctx, r))
 3973			ret = graphql.Null
 3974		}
 3975	}()
 3976	fc := &graphql.FieldContext{
 3977		Object:   "BugConnection",
 3978		Field:    field,
 3979		Args:     nil,
 3980		IsMethod: false,
 3981	}
 3982
 3983	ctx = graphql.WithFieldContext(ctx, fc)
 3984	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3985		ctx = rctx // use context from middleware stack in children
 3986		return obj.Edges, nil
 3987	})
 3988	if err != nil {
 3989		ec.Error(ctx, err)
 3990		return graphql.Null
 3991	}
 3992	if resTmp == nil {
 3993		if !graphql.HasFieldError(ctx, fc) {
 3994			ec.Errorf(ctx, "must not be null")
 3995		}
 3996		return graphql.Null
 3997	}
 3998	res := resTmp.([]*models.BugEdge)
 3999	fc.Result = res
 4000	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 4001}
 4002
 4003func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4004	defer func() {
 4005		if r := recover(); r != nil {
 4006			ec.Error(ctx, ec.Recover(ctx, r))
 4007			ret = graphql.Null
 4008		}
 4009	}()
 4010	fc := &graphql.FieldContext{
 4011		Object:   "BugConnection",
 4012		Field:    field,
 4013		Args:     nil,
 4014		IsMethod: false,
 4015	}
 4016
 4017	ctx = graphql.WithFieldContext(ctx, fc)
 4018	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4019		ctx = rctx // use context from middleware stack in children
 4020		return obj.Nodes, nil
 4021	})
 4022	if err != nil {
 4023		ec.Error(ctx, err)
 4024		return graphql.Null
 4025	}
 4026	if resTmp == nil {
 4027		if !graphql.HasFieldError(ctx, fc) {
 4028			ec.Errorf(ctx, "must not be null")
 4029		}
 4030		return graphql.Null
 4031	}
 4032	res := resTmp.([]models.BugWrapper)
 4033	fc.Result = res
 4034	return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
 4035}
 4036
 4037func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4038	defer func() {
 4039		if r := recover(); r != nil {
 4040			ec.Error(ctx, ec.Recover(ctx, r))
 4041			ret = graphql.Null
 4042		}
 4043	}()
 4044	fc := &graphql.FieldContext{
 4045		Object:   "BugConnection",
 4046		Field:    field,
 4047		Args:     nil,
 4048		IsMethod: false,
 4049	}
 4050
 4051	ctx = graphql.WithFieldContext(ctx, fc)
 4052	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4053		ctx = rctx // use context from middleware stack in children
 4054		return obj.PageInfo, nil
 4055	})
 4056	if err != nil {
 4057		ec.Error(ctx, err)
 4058		return graphql.Null
 4059	}
 4060	if resTmp == nil {
 4061		if !graphql.HasFieldError(ctx, fc) {
 4062			ec.Errorf(ctx, "must not be null")
 4063		}
 4064		return graphql.Null
 4065	}
 4066	res := resTmp.(*models.PageInfo)
 4067	fc.Result = res
 4068	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4069}
 4070
 4071func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4072	defer func() {
 4073		if r := recover(); r != nil {
 4074			ec.Error(ctx, ec.Recover(ctx, r))
 4075			ret = graphql.Null
 4076		}
 4077	}()
 4078	fc := &graphql.FieldContext{
 4079		Object:   "BugConnection",
 4080		Field:    field,
 4081		Args:     nil,
 4082		IsMethod: false,
 4083	}
 4084
 4085	ctx = graphql.WithFieldContext(ctx, fc)
 4086	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4087		ctx = rctx // use context from middleware stack in children
 4088		return obj.TotalCount, nil
 4089	})
 4090	if err != nil {
 4091		ec.Error(ctx, err)
 4092		return graphql.Null
 4093	}
 4094	if resTmp == nil {
 4095		if !graphql.HasFieldError(ctx, fc) {
 4096			ec.Errorf(ctx, "must not be null")
 4097		}
 4098		return graphql.Null
 4099	}
 4100	res := resTmp.(int)
 4101	fc.Result = res
 4102	return ec.marshalNInt2int(ctx, field.Selections, res)
 4103}
 4104
 4105func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4106	defer func() {
 4107		if r := recover(); r != nil {
 4108			ec.Error(ctx, ec.Recover(ctx, r))
 4109			ret = graphql.Null
 4110		}
 4111	}()
 4112	fc := &graphql.FieldContext{
 4113		Object:   "BugEdge",
 4114		Field:    field,
 4115		Args:     nil,
 4116		IsMethod: false,
 4117	}
 4118
 4119	ctx = graphql.WithFieldContext(ctx, fc)
 4120	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4121		ctx = rctx // use context from middleware stack in children
 4122		return obj.Cursor, nil
 4123	})
 4124	if err != nil {
 4125		ec.Error(ctx, err)
 4126		return graphql.Null
 4127	}
 4128	if resTmp == nil {
 4129		if !graphql.HasFieldError(ctx, fc) {
 4130			ec.Errorf(ctx, "must not be null")
 4131		}
 4132		return graphql.Null
 4133	}
 4134	res := resTmp.(string)
 4135	fc.Result = res
 4136	return ec.marshalNString2string(ctx, field.Selections, res)
 4137}
 4138
 4139func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4140	defer func() {
 4141		if r := recover(); r != nil {
 4142			ec.Error(ctx, ec.Recover(ctx, r))
 4143			ret = graphql.Null
 4144		}
 4145	}()
 4146	fc := &graphql.FieldContext{
 4147		Object:   "BugEdge",
 4148		Field:    field,
 4149		Args:     nil,
 4150		IsMethod: false,
 4151	}
 4152
 4153	ctx = graphql.WithFieldContext(ctx, fc)
 4154	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4155		ctx = rctx // use context from middleware stack in children
 4156		return obj.Node, nil
 4157	})
 4158	if err != nil {
 4159		ec.Error(ctx, err)
 4160		return graphql.Null
 4161	}
 4162	if resTmp == nil {
 4163		if !graphql.HasFieldError(ctx, fc) {
 4164			ec.Errorf(ctx, "must not be null")
 4165		}
 4166		return graphql.Null
 4167	}
 4168	res := resTmp.(models.BugWrapper)
 4169	fc.Result = res
 4170	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4171}
 4172
 4173func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4174	defer func() {
 4175		if r := recover(); r != nil {
 4176			ec.Error(ctx, ec.Recover(ctx, r))
 4177			ret = graphql.Null
 4178		}
 4179	}()
 4180	fc := &graphql.FieldContext{
 4181		Object:   "ChangeLabelPayload",
 4182		Field:    field,
 4183		Args:     nil,
 4184		IsMethod: false,
 4185	}
 4186
 4187	ctx = graphql.WithFieldContext(ctx, fc)
 4188	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4189		ctx = rctx // use context from middleware stack in children
 4190		return obj.ClientMutationID, nil
 4191	})
 4192	if err != nil {
 4193		ec.Error(ctx, err)
 4194		return graphql.Null
 4195	}
 4196	if resTmp == nil {
 4197		return graphql.Null
 4198	}
 4199	res := resTmp.(*string)
 4200	fc.Result = res
 4201	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4202}
 4203
 4204func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4205	defer func() {
 4206		if r := recover(); r != nil {
 4207			ec.Error(ctx, ec.Recover(ctx, r))
 4208			ret = graphql.Null
 4209		}
 4210	}()
 4211	fc := &graphql.FieldContext{
 4212		Object:   "ChangeLabelPayload",
 4213		Field:    field,
 4214		Args:     nil,
 4215		IsMethod: false,
 4216	}
 4217
 4218	ctx = graphql.WithFieldContext(ctx, fc)
 4219	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4220		ctx = rctx // use context from middleware stack in children
 4221		return obj.Bug, nil
 4222	})
 4223	if err != nil {
 4224		ec.Error(ctx, err)
 4225		return graphql.Null
 4226	}
 4227	if resTmp == nil {
 4228		if !graphql.HasFieldError(ctx, fc) {
 4229			ec.Errorf(ctx, "must not be null")
 4230		}
 4231		return graphql.Null
 4232	}
 4233	res := resTmp.(models.BugWrapper)
 4234	fc.Result = res
 4235	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4236}
 4237
 4238func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4239	defer func() {
 4240		if r := recover(); r != nil {
 4241			ec.Error(ctx, ec.Recover(ctx, r))
 4242			ret = graphql.Null
 4243		}
 4244	}()
 4245	fc := &graphql.FieldContext{
 4246		Object:   "ChangeLabelPayload",
 4247		Field:    field,
 4248		Args:     nil,
 4249		IsMethod: false,
 4250	}
 4251
 4252	ctx = graphql.WithFieldContext(ctx, fc)
 4253	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4254		ctx = rctx // use context from middleware stack in children
 4255		return obj.Operation, nil
 4256	})
 4257	if err != nil {
 4258		ec.Error(ctx, err)
 4259		return graphql.Null
 4260	}
 4261	if resTmp == nil {
 4262		if !graphql.HasFieldError(ctx, fc) {
 4263			ec.Errorf(ctx, "must not be null")
 4264		}
 4265		return graphql.Null
 4266	}
 4267	res := resTmp.(*bug.LabelChangeOperation)
 4268	fc.Result = res
 4269	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4270}
 4271
 4272func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4273	defer func() {
 4274		if r := recover(); r != nil {
 4275			ec.Error(ctx, ec.Recover(ctx, r))
 4276			ret = graphql.Null
 4277		}
 4278	}()
 4279	fc := &graphql.FieldContext{
 4280		Object:   "ChangeLabelPayload",
 4281		Field:    field,
 4282		Args:     nil,
 4283		IsMethod: false,
 4284	}
 4285
 4286	ctx = graphql.WithFieldContext(ctx, fc)
 4287	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4288		ctx = rctx // use context from middleware stack in children
 4289		return obj.Results, nil
 4290	})
 4291	if err != nil {
 4292		ec.Error(ctx, err)
 4293		return graphql.Null
 4294	}
 4295	if resTmp == nil {
 4296		if !graphql.HasFieldError(ctx, fc) {
 4297			ec.Errorf(ctx, "must not be null")
 4298		}
 4299		return graphql.Null
 4300	}
 4301	res := resTmp.([]*bug.LabelChangeResult)
 4302	fc.Result = res
 4303	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4304}
 4305
 4306func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4307	defer func() {
 4308		if r := recover(); r != nil {
 4309			ec.Error(ctx, ec.Recover(ctx, r))
 4310			ret = graphql.Null
 4311		}
 4312	}()
 4313	fc := &graphql.FieldContext{
 4314		Object:   "CloseBugPayload",
 4315		Field:    field,
 4316		Args:     nil,
 4317		IsMethod: false,
 4318	}
 4319
 4320	ctx = graphql.WithFieldContext(ctx, fc)
 4321	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4322		ctx = rctx // use context from middleware stack in children
 4323		return obj.ClientMutationID, nil
 4324	})
 4325	if err != nil {
 4326		ec.Error(ctx, err)
 4327		return graphql.Null
 4328	}
 4329	if resTmp == nil {
 4330		return graphql.Null
 4331	}
 4332	res := resTmp.(*string)
 4333	fc.Result = res
 4334	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4335}
 4336
 4337func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4338	defer func() {
 4339		if r := recover(); r != nil {
 4340			ec.Error(ctx, ec.Recover(ctx, r))
 4341			ret = graphql.Null
 4342		}
 4343	}()
 4344	fc := &graphql.FieldContext{
 4345		Object:   "CloseBugPayload",
 4346		Field:    field,
 4347		Args:     nil,
 4348		IsMethod: false,
 4349	}
 4350
 4351	ctx = graphql.WithFieldContext(ctx, fc)
 4352	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4353		ctx = rctx // use context from middleware stack in children
 4354		return obj.Bug, nil
 4355	})
 4356	if err != nil {
 4357		ec.Error(ctx, err)
 4358		return graphql.Null
 4359	}
 4360	if resTmp == nil {
 4361		if !graphql.HasFieldError(ctx, fc) {
 4362			ec.Errorf(ctx, "must not be null")
 4363		}
 4364		return graphql.Null
 4365	}
 4366	res := resTmp.(models.BugWrapper)
 4367	fc.Result = res
 4368	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4369}
 4370
 4371func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4372	defer func() {
 4373		if r := recover(); r != nil {
 4374			ec.Error(ctx, ec.Recover(ctx, r))
 4375			ret = graphql.Null
 4376		}
 4377	}()
 4378	fc := &graphql.FieldContext{
 4379		Object:   "CloseBugPayload",
 4380		Field:    field,
 4381		Args:     nil,
 4382		IsMethod: false,
 4383	}
 4384
 4385	ctx = graphql.WithFieldContext(ctx, fc)
 4386	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4387		ctx = rctx // use context from middleware stack in children
 4388		return obj.Operation, nil
 4389	})
 4390	if err != nil {
 4391		ec.Error(ctx, err)
 4392		return graphql.Null
 4393	}
 4394	if resTmp == nil {
 4395		if !graphql.HasFieldError(ctx, fc) {
 4396			ec.Errorf(ctx, "must not be null")
 4397		}
 4398		return graphql.Null
 4399	}
 4400	res := resTmp.(*bug.SetStatusOperation)
 4401	fc.Result = res
 4402	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4403}
 4404
 4405func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4406	defer func() {
 4407		if r := recover(); r != nil {
 4408			ec.Error(ctx, ec.Recover(ctx, r))
 4409			ret = graphql.Null
 4410		}
 4411	}()
 4412	fc := &graphql.FieldContext{
 4413		Object:   "Color",
 4414		Field:    field,
 4415		Args:     nil,
 4416		IsMethod: true,
 4417	}
 4418
 4419	ctx = graphql.WithFieldContext(ctx, fc)
 4420	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4421		ctx = rctx // use context from middleware stack in children
 4422		return ec.resolvers.Color().R(rctx, obj)
 4423	})
 4424	if err != nil {
 4425		ec.Error(ctx, err)
 4426		return graphql.Null
 4427	}
 4428	if resTmp == nil {
 4429		if !graphql.HasFieldError(ctx, fc) {
 4430			ec.Errorf(ctx, "must not be null")
 4431		}
 4432		return graphql.Null
 4433	}
 4434	res := resTmp.(int)
 4435	fc.Result = res
 4436	return ec.marshalNInt2int(ctx, field.Selections, res)
 4437}
 4438
 4439func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4440	defer func() {
 4441		if r := recover(); r != nil {
 4442			ec.Error(ctx, ec.Recover(ctx, r))
 4443			ret = graphql.Null
 4444		}
 4445	}()
 4446	fc := &graphql.FieldContext{
 4447		Object:   "Color",
 4448		Field:    field,
 4449		Args:     nil,
 4450		IsMethod: true,
 4451	}
 4452
 4453	ctx = graphql.WithFieldContext(ctx, fc)
 4454	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4455		ctx = rctx // use context from middleware stack in children
 4456		return ec.resolvers.Color().G(rctx, obj)
 4457	})
 4458	if err != nil {
 4459		ec.Error(ctx, err)
 4460		return graphql.Null
 4461	}
 4462	if resTmp == nil {
 4463		if !graphql.HasFieldError(ctx, fc) {
 4464			ec.Errorf(ctx, "must not be null")
 4465		}
 4466		return graphql.Null
 4467	}
 4468	res := resTmp.(int)
 4469	fc.Result = res
 4470	return ec.marshalNInt2int(ctx, field.Selections, res)
 4471}
 4472
 4473func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4474	defer func() {
 4475		if r := recover(); r != nil {
 4476			ec.Error(ctx, ec.Recover(ctx, r))
 4477			ret = graphql.Null
 4478		}
 4479	}()
 4480	fc := &graphql.FieldContext{
 4481		Object:   "Color",
 4482		Field:    field,
 4483		Args:     nil,
 4484		IsMethod: true,
 4485	}
 4486
 4487	ctx = graphql.WithFieldContext(ctx, fc)
 4488	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4489		ctx = rctx // use context from middleware stack in children
 4490		return ec.resolvers.Color().B(rctx, obj)
 4491	})
 4492	if err != nil {
 4493		ec.Error(ctx, err)
 4494		return graphql.Null
 4495	}
 4496	if resTmp == nil {
 4497		if !graphql.HasFieldError(ctx, fc) {
 4498			ec.Errorf(ctx, "must not be null")
 4499		}
 4500		return graphql.Null
 4501	}
 4502	res := resTmp.(int)
 4503	fc.Result = res
 4504	return ec.marshalNInt2int(ctx, field.Selections, res)
 4505}
 4506
 4507func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4508	defer func() {
 4509		if r := recover(); r != nil {
 4510			ec.Error(ctx, ec.Recover(ctx, r))
 4511			ret = graphql.Null
 4512		}
 4513	}()
 4514	fc := &graphql.FieldContext{
 4515		Object:   "Comment",
 4516		Field:    field,
 4517		Args:     nil,
 4518		IsMethod: true,
 4519	}
 4520
 4521	ctx = graphql.WithFieldContext(ctx, fc)
 4522	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4523		ctx = rctx // use context from middleware stack in children
 4524		return ec.resolvers.Comment().Author(rctx, obj)
 4525	})
 4526	if err != nil {
 4527		ec.Error(ctx, err)
 4528		return graphql.Null
 4529	}
 4530	if resTmp == nil {
 4531		if !graphql.HasFieldError(ctx, fc) {
 4532			ec.Errorf(ctx, "must not be null")
 4533		}
 4534		return graphql.Null
 4535	}
 4536	res := resTmp.(models.IdentityWrapper)
 4537	fc.Result = res
 4538	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4539}
 4540
 4541func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4542	defer func() {
 4543		if r := recover(); r != nil {
 4544			ec.Error(ctx, ec.Recover(ctx, r))
 4545			ret = graphql.Null
 4546		}
 4547	}()
 4548	fc := &graphql.FieldContext{
 4549		Object:   "Comment",
 4550		Field:    field,
 4551		Args:     nil,
 4552		IsMethod: false,
 4553	}
 4554
 4555	ctx = graphql.WithFieldContext(ctx, fc)
 4556	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4557		ctx = rctx // use context from middleware stack in children
 4558		return obj.Message, nil
 4559	})
 4560	if err != nil {
 4561		ec.Error(ctx, err)
 4562		return graphql.Null
 4563	}
 4564	if resTmp == nil {
 4565		if !graphql.HasFieldError(ctx, fc) {
 4566			ec.Errorf(ctx, "must not be null")
 4567		}
 4568		return graphql.Null
 4569	}
 4570	res := resTmp.(string)
 4571	fc.Result = res
 4572	return ec.marshalNString2string(ctx, field.Selections, res)
 4573}
 4574
 4575func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4576	defer func() {
 4577		if r := recover(); r != nil {
 4578			ec.Error(ctx, ec.Recover(ctx, r))
 4579			ret = graphql.Null
 4580		}
 4581	}()
 4582	fc := &graphql.FieldContext{
 4583		Object:   "Comment",
 4584		Field:    field,
 4585		Args:     nil,
 4586		IsMethod: false,
 4587	}
 4588
 4589	ctx = graphql.WithFieldContext(ctx, fc)
 4590	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4591		ctx = rctx // use context from middleware stack in children
 4592		return obj.Files, nil
 4593	})
 4594	if err != nil {
 4595		ec.Error(ctx, err)
 4596		return graphql.Null
 4597	}
 4598	if resTmp == nil {
 4599		if !graphql.HasFieldError(ctx, fc) {
 4600			ec.Errorf(ctx, "must not be null")
 4601		}
 4602		return graphql.Null
 4603	}
 4604	res := resTmp.([]git.Hash)
 4605	fc.Result = res
 4606	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 4607}
 4608
 4609func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4610	defer func() {
 4611		if r := recover(); r != nil {
 4612			ec.Error(ctx, ec.Recover(ctx, r))
 4613			ret = graphql.Null
 4614		}
 4615	}()
 4616	fc := &graphql.FieldContext{
 4617		Object:   "CommentConnection",
 4618		Field:    field,
 4619		Args:     nil,
 4620		IsMethod: false,
 4621	}
 4622
 4623	ctx = graphql.WithFieldContext(ctx, fc)
 4624	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4625		ctx = rctx // use context from middleware stack in children
 4626		return obj.Edges, nil
 4627	})
 4628	if err != nil {
 4629		ec.Error(ctx, err)
 4630		return graphql.Null
 4631	}
 4632	if resTmp == nil {
 4633		if !graphql.HasFieldError(ctx, fc) {
 4634			ec.Errorf(ctx, "must not be null")
 4635		}
 4636		return graphql.Null
 4637	}
 4638	res := resTmp.([]*models.CommentEdge)
 4639	fc.Result = res
 4640	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4641}
 4642
 4643func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4644	defer func() {
 4645		if r := recover(); r != nil {
 4646			ec.Error(ctx, ec.Recover(ctx, r))
 4647			ret = graphql.Null
 4648		}
 4649	}()
 4650	fc := &graphql.FieldContext{
 4651		Object:   "CommentConnection",
 4652		Field:    field,
 4653		Args:     nil,
 4654		IsMethod: false,
 4655	}
 4656
 4657	ctx = graphql.WithFieldContext(ctx, fc)
 4658	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4659		ctx = rctx // use context from middleware stack in children
 4660		return obj.Nodes, nil
 4661	})
 4662	if err != nil {
 4663		ec.Error(ctx, err)
 4664		return graphql.Null
 4665	}
 4666	if resTmp == nil {
 4667		if !graphql.HasFieldError(ctx, fc) {
 4668			ec.Errorf(ctx, "must not be null")
 4669		}
 4670		return graphql.Null
 4671	}
 4672	res := resTmp.([]*bug.Comment)
 4673	fc.Result = res
 4674	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 4675}
 4676
 4677func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4678	defer func() {
 4679		if r := recover(); r != nil {
 4680			ec.Error(ctx, ec.Recover(ctx, r))
 4681			ret = graphql.Null
 4682		}
 4683	}()
 4684	fc := &graphql.FieldContext{
 4685		Object:   "CommentConnection",
 4686		Field:    field,
 4687		Args:     nil,
 4688		IsMethod: false,
 4689	}
 4690
 4691	ctx = graphql.WithFieldContext(ctx, fc)
 4692	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4693		ctx = rctx // use context from middleware stack in children
 4694		return obj.PageInfo, nil
 4695	})
 4696	if err != nil {
 4697		ec.Error(ctx, err)
 4698		return graphql.Null
 4699	}
 4700	if resTmp == nil {
 4701		if !graphql.HasFieldError(ctx, fc) {
 4702			ec.Errorf(ctx, "must not be null")
 4703		}
 4704		return graphql.Null
 4705	}
 4706	res := resTmp.(*models.PageInfo)
 4707	fc.Result = res
 4708	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4709}
 4710
 4711func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4712	defer func() {
 4713		if r := recover(); r != nil {
 4714			ec.Error(ctx, ec.Recover(ctx, r))
 4715			ret = graphql.Null
 4716		}
 4717	}()
 4718	fc := &graphql.FieldContext{
 4719		Object:   "CommentConnection",
 4720		Field:    field,
 4721		Args:     nil,
 4722		IsMethod: false,
 4723	}
 4724
 4725	ctx = graphql.WithFieldContext(ctx, fc)
 4726	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4727		ctx = rctx // use context from middleware stack in children
 4728		return obj.TotalCount, nil
 4729	})
 4730	if err != nil {
 4731		ec.Error(ctx, err)
 4732		return graphql.Null
 4733	}
 4734	if resTmp == nil {
 4735		if !graphql.HasFieldError(ctx, fc) {
 4736			ec.Errorf(ctx, "must not be null")
 4737		}
 4738		return graphql.Null
 4739	}
 4740	res := resTmp.(int)
 4741	fc.Result = res
 4742	return ec.marshalNInt2int(ctx, field.Selections, res)
 4743}
 4744
 4745func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4746	defer func() {
 4747		if r := recover(); r != nil {
 4748			ec.Error(ctx, ec.Recover(ctx, r))
 4749			ret = graphql.Null
 4750		}
 4751	}()
 4752	fc := &graphql.FieldContext{
 4753		Object:   "CommentEdge",
 4754		Field:    field,
 4755		Args:     nil,
 4756		IsMethod: false,
 4757	}
 4758
 4759	ctx = graphql.WithFieldContext(ctx, fc)
 4760	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4761		ctx = rctx // use context from middleware stack in children
 4762		return obj.Cursor, nil
 4763	})
 4764	if err != nil {
 4765		ec.Error(ctx, err)
 4766		return graphql.Null
 4767	}
 4768	if resTmp == nil {
 4769		if !graphql.HasFieldError(ctx, fc) {
 4770			ec.Errorf(ctx, "must not be null")
 4771		}
 4772		return graphql.Null
 4773	}
 4774	res := resTmp.(string)
 4775	fc.Result = res
 4776	return ec.marshalNString2string(ctx, field.Selections, res)
 4777}
 4778
 4779func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4780	defer func() {
 4781		if r := recover(); r != nil {
 4782			ec.Error(ctx, ec.Recover(ctx, r))
 4783			ret = graphql.Null
 4784		}
 4785	}()
 4786	fc := &graphql.FieldContext{
 4787		Object:   "CommentEdge",
 4788		Field:    field,
 4789		Args:     nil,
 4790		IsMethod: false,
 4791	}
 4792
 4793	ctx = graphql.WithFieldContext(ctx, fc)
 4794	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4795		ctx = rctx // use context from middleware stack in children
 4796		return obj.Node, nil
 4797	})
 4798	if err != nil {
 4799		ec.Error(ctx, err)
 4800		return graphql.Null
 4801	}
 4802	if resTmp == nil {
 4803		if !graphql.HasFieldError(ctx, fc) {
 4804			ec.Errorf(ctx, "must not be null")
 4805		}
 4806		return graphql.Null
 4807	}
 4808	res := resTmp.(*bug.Comment)
 4809	fc.Result = res
 4810	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4811}
 4812
 4813func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4814	defer func() {
 4815		if r := recover(); r != nil {
 4816			ec.Error(ctx, ec.Recover(ctx, r))
 4817			ret = graphql.Null
 4818		}
 4819	}()
 4820	fc := &graphql.FieldContext{
 4821		Object:   "CommentHistoryStep",
 4822		Field:    field,
 4823		Args:     nil,
 4824		IsMethod: false,
 4825	}
 4826
 4827	ctx = graphql.WithFieldContext(ctx, fc)
 4828	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4829		ctx = rctx // use context from middleware stack in children
 4830		return obj.Message, nil
 4831	})
 4832	if err != nil {
 4833		ec.Error(ctx, err)
 4834		return graphql.Null
 4835	}
 4836	if resTmp == nil {
 4837		if !graphql.HasFieldError(ctx, fc) {
 4838			ec.Errorf(ctx, "must not be null")
 4839		}
 4840		return graphql.Null
 4841	}
 4842	res := resTmp.(string)
 4843	fc.Result = res
 4844	return ec.marshalNString2string(ctx, field.Selections, res)
 4845}
 4846
 4847func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4848	defer func() {
 4849		if r := recover(); r != nil {
 4850			ec.Error(ctx, ec.Recover(ctx, r))
 4851			ret = graphql.Null
 4852		}
 4853	}()
 4854	fc := &graphql.FieldContext{
 4855		Object:   "CommentHistoryStep",
 4856		Field:    field,
 4857		Args:     nil,
 4858		IsMethod: true,
 4859	}
 4860
 4861	ctx = graphql.WithFieldContext(ctx, fc)
 4862	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4863		ctx = rctx // use context from middleware stack in children
 4864		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4865	})
 4866	if err != nil {
 4867		ec.Error(ctx, err)
 4868		return graphql.Null
 4869	}
 4870	if resTmp == nil {
 4871		if !graphql.HasFieldError(ctx, fc) {
 4872			ec.Errorf(ctx, "must not be null")
 4873		}
 4874		return graphql.Null
 4875	}
 4876	res := resTmp.(*time.Time)
 4877	fc.Result = res
 4878	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4879}
 4880
 4881func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4882	defer func() {
 4883		if r := recover(); r != nil {
 4884			ec.Error(ctx, ec.Recover(ctx, r))
 4885			ret = graphql.Null
 4886		}
 4887	}()
 4888	fc := &graphql.FieldContext{
 4889		Object:   "CreateOperation",
 4890		Field:    field,
 4891		Args:     nil,
 4892		IsMethod: true,
 4893	}
 4894
 4895	ctx = graphql.WithFieldContext(ctx, fc)
 4896	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4897		ctx = rctx // use context from middleware stack in children
 4898		return ec.resolvers.CreateOperation().ID(rctx, obj)
 4899	})
 4900	if err != nil {
 4901		ec.Error(ctx, err)
 4902		return graphql.Null
 4903	}
 4904	if resTmp == nil {
 4905		if !graphql.HasFieldError(ctx, fc) {
 4906			ec.Errorf(ctx, "must not be null")
 4907		}
 4908		return graphql.Null
 4909	}
 4910	res := resTmp.(string)
 4911	fc.Result = res
 4912	return ec.marshalNString2string(ctx, field.Selections, res)
 4913}
 4914
 4915func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4916	defer func() {
 4917		if r := recover(); r != nil {
 4918			ec.Error(ctx, ec.Recover(ctx, r))
 4919			ret = graphql.Null
 4920		}
 4921	}()
 4922	fc := &graphql.FieldContext{
 4923		Object:   "CreateOperation",
 4924		Field:    field,
 4925		Args:     nil,
 4926		IsMethod: true,
 4927	}
 4928
 4929	ctx = graphql.WithFieldContext(ctx, fc)
 4930	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4931		ctx = rctx // use context from middleware stack in children
 4932		return ec.resolvers.CreateOperation().Author(rctx, obj)
 4933	})
 4934	if err != nil {
 4935		ec.Error(ctx, err)
 4936		return graphql.Null
 4937	}
 4938	if resTmp == nil {
 4939		if !graphql.HasFieldError(ctx, fc) {
 4940			ec.Errorf(ctx, "must not be null")
 4941		}
 4942		return graphql.Null
 4943	}
 4944	res := resTmp.(models.IdentityWrapper)
 4945	fc.Result = res
 4946	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4947}
 4948
 4949func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4950	defer func() {
 4951		if r := recover(); r != nil {
 4952			ec.Error(ctx, ec.Recover(ctx, r))
 4953			ret = graphql.Null
 4954		}
 4955	}()
 4956	fc := &graphql.FieldContext{
 4957		Object:   "CreateOperation",
 4958		Field:    field,
 4959		Args:     nil,
 4960		IsMethod: true,
 4961	}
 4962
 4963	ctx = graphql.WithFieldContext(ctx, fc)
 4964	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4965		ctx = rctx // use context from middleware stack in children
 4966		return ec.resolvers.CreateOperation().Date(rctx, obj)
 4967	})
 4968	if err != nil {
 4969		ec.Error(ctx, err)
 4970		return graphql.Null
 4971	}
 4972	if resTmp == nil {
 4973		if !graphql.HasFieldError(ctx, fc) {
 4974			ec.Errorf(ctx, "must not be null")
 4975		}
 4976		return graphql.Null
 4977	}
 4978	res := resTmp.(*time.Time)
 4979	fc.Result = res
 4980	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4981}
 4982
 4983func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4984	defer func() {
 4985		if r := recover(); r != nil {
 4986			ec.Error(ctx, ec.Recover(ctx, r))
 4987			ret = graphql.Null
 4988		}
 4989	}()
 4990	fc := &graphql.FieldContext{
 4991		Object:   "CreateOperation",
 4992		Field:    field,
 4993		Args:     nil,
 4994		IsMethod: false,
 4995	}
 4996
 4997	ctx = graphql.WithFieldContext(ctx, fc)
 4998	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4999		ctx = rctx // use context from middleware stack in children
 5000		return obj.Title, nil
 5001	})
 5002	if err != nil {
 5003		ec.Error(ctx, err)
 5004		return graphql.Null
 5005	}
 5006	if resTmp == nil {
 5007		if !graphql.HasFieldError(ctx, fc) {
 5008			ec.Errorf(ctx, "must not be null")
 5009		}
 5010		return graphql.Null
 5011	}
 5012	res := resTmp.(string)
 5013	fc.Result = res
 5014	return ec.marshalNString2string(ctx, field.Selections, res)
 5015}
 5016
 5017func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5018	defer func() {
 5019		if r := recover(); r != nil {
 5020			ec.Error(ctx, ec.Recover(ctx, r))
 5021			ret = graphql.Null
 5022		}
 5023	}()
 5024	fc := &graphql.FieldContext{
 5025		Object:   "CreateOperation",
 5026		Field:    field,
 5027		Args:     nil,
 5028		IsMethod: false,
 5029	}
 5030
 5031	ctx = graphql.WithFieldContext(ctx, fc)
 5032	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5033		ctx = rctx // use context from middleware stack in children
 5034		return obj.Message, nil
 5035	})
 5036	if err != nil {
 5037		ec.Error(ctx, err)
 5038		return graphql.Null
 5039	}
 5040	if resTmp == nil {
 5041		if !graphql.HasFieldError(ctx, fc) {
 5042			ec.Errorf(ctx, "must not be null")
 5043		}
 5044		return graphql.Null
 5045	}
 5046	res := resTmp.(string)
 5047	fc.Result = res
 5048	return ec.marshalNString2string(ctx, field.Selections, res)
 5049}
 5050
 5051func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5052	defer func() {
 5053		if r := recover(); r != nil {
 5054			ec.Error(ctx, ec.Recover(ctx, r))
 5055			ret = graphql.Null
 5056		}
 5057	}()
 5058	fc := &graphql.FieldContext{
 5059		Object:   "CreateOperation",
 5060		Field:    field,
 5061		Args:     nil,
 5062		IsMethod: false,
 5063	}
 5064
 5065	ctx = graphql.WithFieldContext(ctx, fc)
 5066	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5067		ctx = rctx // use context from middleware stack in children
 5068		return obj.Files, nil
 5069	})
 5070	if err != nil {
 5071		ec.Error(ctx, err)
 5072		return graphql.Null
 5073	}
 5074	if resTmp == nil {
 5075		if !graphql.HasFieldError(ctx, fc) {
 5076			ec.Errorf(ctx, "must not be null")
 5077		}
 5078		return graphql.Null
 5079	}
 5080	res := resTmp.([]git.Hash)
 5081	fc.Result = res
 5082	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5083}
 5084
 5085func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5086	defer func() {
 5087		if r := recover(); r != nil {
 5088			ec.Error(ctx, ec.Recover(ctx, r))
 5089			ret = graphql.Null
 5090		}
 5091	}()
 5092	fc := &graphql.FieldContext{
 5093		Object:   "CreateTimelineItem",
 5094		Field:    field,
 5095		Args:     nil,
 5096		IsMethod: true,
 5097	}
 5098
 5099	ctx = graphql.WithFieldContext(ctx, fc)
 5100	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5101		ctx = rctx // use context from middleware stack in children
 5102		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5103	})
 5104	if err != nil {
 5105		ec.Error(ctx, err)
 5106		return graphql.Null
 5107	}
 5108	if resTmp == nil {
 5109		if !graphql.HasFieldError(ctx, fc) {
 5110			ec.Errorf(ctx, "must not be null")
 5111		}
 5112		return graphql.Null
 5113	}
 5114	res := resTmp.(string)
 5115	fc.Result = res
 5116	return ec.marshalNString2string(ctx, field.Selections, res)
 5117}
 5118
 5119func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5120	defer func() {
 5121		if r := recover(); r != nil {
 5122			ec.Error(ctx, ec.Recover(ctx, r))
 5123			ret = graphql.Null
 5124		}
 5125	}()
 5126	fc := &graphql.FieldContext{
 5127		Object:   "CreateTimelineItem",
 5128		Field:    field,
 5129		Args:     nil,
 5130		IsMethod: true,
 5131	}
 5132
 5133	ctx = graphql.WithFieldContext(ctx, fc)
 5134	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5135		ctx = rctx // use context from middleware stack in children
 5136		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
 5137	})
 5138	if err != nil {
 5139		ec.Error(ctx, err)
 5140		return graphql.Null
 5141	}
 5142	if resTmp == nil {
 5143		if !graphql.HasFieldError(ctx, fc) {
 5144			ec.Errorf(ctx, "must not be null")
 5145		}
 5146		return graphql.Null
 5147	}
 5148	res := resTmp.(models.IdentityWrapper)
 5149	fc.Result = res
 5150	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5151}
 5152
 5153func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5154	defer func() {
 5155		if r := recover(); r != nil {
 5156			ec.Error(ctx, ec.Recover(ctx, r))
 5157			ret = graphql.Null
 5158		}
 5159	}()
 5160	fc := &graphql.FieldContext{
 5161		Object:   "CreateTimelineItem",
 5162		Field:    field,
 5163		Args:     nil,
 5164		IsMethod: false,
 5165	}
 5166
 5167	ctx = graphql.WithFieldContext(ctx, fc)
 5168	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5169		ctx = rctx // use context from middleware stack in children
 5170		return obj.Message, nil
 5171	})
 5172	if err != nil {
 5173		ec.Error(ctx, err)
 5174		return graphql.Null
 5175	}
 5176	if resTmp == nil {
 5177		if !graphql.HasFieldError(ctx, fc) {
 5178			ec.Errorf(ctx, "must not be null")
 5179		}
 5180		return graphql.Null
 5181	}
 5182	res := resTmp.(string)
 5183	fc.Result = res
 5184	return ec.marshalNString2string(ctx, field.Selections, res)
 5185}
 5186
 5187func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5188	defer func() {
 5189		if r := recover(); r != nil {
 5190			ec.Error(ctx, ec.Recover(ctx, r))
 5191			ret = graphql.Null
 5192		}
 5193	}()
 5194	fc := &graphql.FieldContext{
 5195		Object:   "CreateTimelineItem",
 5196		Field:    field,
 5197		Args:     nil,
 5198		IsMethod: true,
 5199	}
 5200
 5201	ctx = graphql.WithFieldContext(ctx, fc)
 5202	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5203		ctx = rctx // use context from middleware stack in children
 5204		return obj.MessageIsEmpty(), nil
 5205	})
 5206	if err != nil {
 5207		ec.Error(ctx, err)
 5208		return graphql.Null
 5209	}
 5210	if resTmp == nil {
 5211		if !graphql.HasFieldError(ctx, fc) {
 5212			ec.Errorf(ctx, "must not be null")
 5213		}
 5214		return graphql.Null
 5215	}
 5216	res := resTmp.(bool)
 5217	fc.Result = res
 5218	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5219}
 5220
 5221func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5222	defer func() {
 5223		if r := recover(); r != nil {
 5224			ec.Error(ctx, ec.Recover(ctx, r))
 5225			ret = graphql.Null
 5226		}
 5227	}()
 5228	fc := &graphql.FieldContext{
 5229		Object:   "CreateTimelineItem",
 5230		Field:    field,
 5231		Args:     nil,
 5232		IsMethod: false,
 5233	}
 5234
 5235	ctx = graphql.WithFieldContext(ctx, fc)
 5236	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5237		ctx = rctx // use context from middleware stack in children
 5238		return obj.Files, nil
 5239	})
 5240	if err != nil {
 5241		ec.Error(ctx, err)
 5242		return graphql.Null
 5243	}
 5244	if resTmp == nil {
 5245		if !graphql.HasFieldError(ctx, fc) {
 5246			ec.Errorf(ctx, "must not be null")
 5247		}
 5248		return graphql.Null
 5249	}
 5250	res := resTmp.([]git.Hash)
 5251	fc.Result = res
 5252	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5253}
 5254
 5255func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5256	defer func() {
 5257		if r := recover(); r != nil {
 5258			ec.Error(ctx, ec.Recover(ctx, r))
 5259			ret = graphql.Null
 5260		}
 5261	}()
 5262	fc := &graphql.FieldContext{
 5263		Object:   "CreateTimelineItem",
 5264		Field:    field,
 5265		Args:     nil,
 5266		IsMethod: true,
 5267	}
 5268
 5269	ctx = graphql.WithFieldContext(ctx, fc)
 5270	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5271		ctx = rctx // use context from middleware stack in children
 5272		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5273	})
 5274	if err != nil {
 5275		ec.Error(ctx, err)
 5276		return graphql.Null
 5277	}
 5278	if resTmp == nil {
 5279		if !graphql.HasFieldError(ctx, fc) {
 5280			ec.Errorf(ctx, "must not be null")
 5281		}
 5282		return graphql.Null
 5283	}
 5284	res := resTmp.(*time.Time)
 5285	fc.Result = res
 5286	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5287}
 5288
 5289func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5290	defer func() {
 5291		if r := recover(); r != nil {
 5292			ec.Error(ctx, ec.Recover(ctx, r))
 5293			ret = graphql.Null
 5294		}
 5295	}()
 5296	fc := &graphql.FieldContext{
 5297		Object:   "CreateTimelineItem",
 5298		Field:    field,
 5299		Args:     nil,
 5300		IsMethod: true,
 5301	}
 5302
 5303	ctx = graphql.WithFieldContext(ctx, fc)
 5304	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5305		ctx = rctx // use context from middleware stack in children
 5306		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5307	})
 5308	if err != nil {
 5309		ec.Error(ctx, err)
 5310		return graphql.Null
 5311	}
 5312	if resTmp == nil {
 5313		if !graphql.HasFieldError(ctx, fc) {
 5314			ec.Errorf(ctx, "must not be null")
 5315		}
 5316		return graphql.Null
 5317	}
 5318	res := resTmp.(*time.Time)
 5319	fc.Result = res
 5320	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5321}
 5322
 5323func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5324	defer func() {
 5325		if r := recover(); r != nil {
 5326			ec.Error(ctx, ec.Recover(ctx, r))
 5327			ret = graphql.Null
 5328		}
 5329	}()
 5330	fc := &graphql.FieldContext{
 5331		Object:   "CreateTimelineItem",
 5332		Field:    field,
 5333		Args:     nil,
 5334		IsMethod: true,
 5335	}
 5336
 5337	ctx = graphql.WithFieldContext(ctx, fc)
 5338	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5339		ctx = rctx // use context from middleware stack in children
 5340		return obj.Edited(), nil
 5341	})
 5342	if err != nil {
 5343		ec.Error(ctx, err)
 5344		return graphql.Null
 5345	}
 5346	if resTmp == nil {
 5347		if !graphql.HasFieldError(ctx, fc) {
 5348			ec.Errorf(ctx, "must not be null")
 5349		}
 5350		return graphql.Null
 5351	}
 5352	res := resTmp.(bool)
 5353	fc.Result = res
 5354	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5355}
 5356
 5357func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5358	defer func() {
 5359		if r := recover(); r != nil {
 5360			ec.Error(ctx, ec.Recover(ctx, r))
 5361			ret = graphql.Null
 5362		}
 5363	}()
 5364	fc := &graphql.FieldContext{
 5365		Object:   "CreateTimelineItem",
 5366		Field:    field,
 5367		Args:     nil,
 5368		IsMethod: false,
 5369	}
 5370
 5371	ctx = graphql.WithFieldContext(ctx, fc)
 5372	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5373		ctx = rctx // use context from middleware stack in children
 5374		return obj.History, nil
 5375	})
 5376	if err != nil {
 5377		ec.Error(ctx, err)
 5378		return graphql.Null
 5379	}
 5380	if resTmp == nil {
 5381		if !graphql.HasFieldError(ctx, fc) {
 5382			ec.Errorf(ctx, "must not be null")
 5383		}
 5384		return graphql.Null
 5385	}
 5386	res := resTmp.([]bug.CommentHistoryStep)
 5387	fc.Result = res
 5388	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5389}
 5390
 5391func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5392	defer func() {
 5393		if r := recover(); r != nil {
 5394			ec.Error(ctx, ec.Recover(ctx, r))
 5395			ret = graphql.Null
 5396		}
 5397	}()
 5398	fc := &graphql.FieldContext{
 5399		Object:   "EditCommentOperation",
 5400		Field:    field,
 5401		Args:     nil,
 5402		IsMethod: true,
 5403	}
 5404
 5405	ctx = graphql.WithFieldContext(ctx, fc)
 5406	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5407		ctx = rctx // use context from middleware stack in children
 5408		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5409	})
 5410	if err != nil {
 5411		ec.Error(ctx, err)
 5412		return graphql.Null
 5413	}
 5414	if resTmp == nil {
 5415		if !graphql.HasFieldError(ctx, fc) {
 5416			ec.Errorf(ctx, "must not be null")
 5417		}
 5418		return graphql.Null
 5419	}
 5420	res := resTmp.(string)
 5421	fc.Result = res
 5422	return ec.marshalNString2string(ctx, field.Selections, res)
 5423}
 5424
 5425func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5426	defer func() {
 5427		if r := recover(); r != nil {
 5428			ec.Error(ctx, ec.Recover(ctx, r))
 5429			ret = graphql.Null
 5430		}
 5431	}()
 5432	fc := &graphql.FieldContext{
 5433		Object:   "EditCommentOperation",
 5434		Field:    field,
 5435		Args:     nil,
 5436		IsMethod: true,
 5437	}
 5438
 5439	ctx = graphql.WithFieldContext(ctx, fc)
 5440	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5441		ctx = rctx // use context from middleware stack in children
 5442		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
 5443	})
 5444	if err != nil {
 5445		ec.Error(ctx, err)
 5446		return graphql.Null
 5447	}
 5448	if resTmp == nil {
 5449		if !graphql.HasFieldError(ctx, fc) {
 5450			ec.Errorf(ctx, "must not be null")
 5451		}
 5452		return graphql.Null
 5453	}
 5454	res := resTmp.(models.IdentityWrapper)
 5455	fc.Result = res
 5456	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5457}
 5458
 5459func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5460	defer func() {
 5461		if r := recover(); r != nil {
 5462			ec.Error(ctx, ec.Recover(ctx, r))
 5463			ret = graphql.Null
 5464		}
 5465	}()
 5466	fc := &graphql.FieldContext{
 5467		Object:   "EditCommentOperation",
 5468		Field:    field,
 5469		Args:     nil,
 5470		IsMethod: true,
 5471	}
 5472
 5473	ctx = graphql.WithFieldContext(ctx, fc)
 5474	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5475		ctx = rctx // use context from middleware stack in children
 5476		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5477	})
 5478	if err != nil {
 5479		ec.Error(ctx, err)
 5480		return graphql.Null
 5481	}
 5482	if resTmp == nil {
 5483		if !graphql.HasFieldError(ctx, fc) {
 5484			ec.Errorf(ctx, "must not be null")
 5485		}
 5486		return graphql.Null
 5487	}
 5488	res := resTmp.(*time.Time)
 5489	fc.Result = res
 5490	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5491}
 5492
 5493func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5494	defer func() {
 5495		if r := recover(); r != nil {
 5496			ec.Error(ctx, ec.Recover(ctx, r))
 5497			ret = graphql.Null
 5498		}
 5499	}()
 5500	fc := &graphql.FieldContext{
 5501		Object:   "EditCommentOperation",
 5502		Field:    field,
 5503		Args:     nil,
 5504		IsMethod: true,
 5505	}
 5506
 5507	ctx = graphql.WithFieldContext(ctx, fc)
 5508	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5509		ctx = rctx // use context from middleware stack in children
 5510		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5511	})
 5512	if err != nil {
 5513		ec.Error(ctx, err)
 5514		return graphql.Null
 5515	}
 5516	if resTmp == nil {
 5517		if !graphql.HasFieldError(ctx, fc) {
 5518			ec.Errorf(ctx, "must not be null")
 5519		}
 5520		return graphql.Null
 5521	}
 5522	res := resTmp.(string)
 5523	fc.Result = res
 5524	return ec.marshalNString2string(ctx, field.Selections, res)
 5525}
 5526
 5527func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5528	defer func() {
 5529		if r := recover(); r != nil {
 5530			ec.Error(ctx, ec.Recover(ctx, r))
 5531			ret = graphql.Null
 5532		}
 5533	}()
 5534	fc := &graphql.FieldContext{
 5535		Object:   "EditCommentOperation",
 5536		Field:    field,
 5537		Args:     nil,
 5538		IsMethod: false,
 5539	}
 5540
 5541	ctx = graphql.WithFieldContext(ctx, fc)
 5542	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5543		ctx = rctx // use context from middleware stack in children
 5544		return obj.Message, nil
 5545	})
 5546	if err != nil {
 5547		ec.Error(ctx, err)
 5548		return graphql.Null
 5549	}
 5550	if resTmp == nil {
 5551		if !graphql.HasFieldError(ctx, fc) {
 5552			ec.Errorf(ctx, "must not be null")
 5553		}
 5554		return graphql.Null
 5555	}
 5556	res := resTmp.(string)
 5557	fc.Result = res
 5558	return ec.marshalNString2string(ctx, field.Selections, res)
 5559}
 5560
 5561func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5562	defer func() {
 5563		if r := recover(); r != nil {
 5564			ec.Error(ctx, ec.Recover(ctx, r))
 5565			ret = graphql.Null
 5566		}
 5567	}()
 5568	fc := &graphql.FieldContext{
 5569		Object:   "EditCommentOperation",
 5570		Field:    field,
 5571		Args:     nil,
 5572		IsMethod: false,
 5573	}
 5574
 5575	ctx = graphql.WithFieldContext(ctx, fc)
 5576	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5577		ctx = rctx // use context from middleware stack in children
 5578		return obj.Files, nil
 5579	})
 5580	if err != nil {
 5581		ec.Error(ctx, err)
 5582		return graphql.Null
 5583	}
 5584	if resTmp == nil {
 5585		if !graphql.HasFieldError(ctx, fc) {
 5586			ec.Errorf(ctx, "must not be null")
 5587		}
 5588		return graphql.Null
 5589	}
 5590	res := resTmp.([]git.Hash)
 5591	fc.Result = res
 5592	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5593}
 5594
 5595func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5596	defer func() {
 5597		if r := recover(); r != nil {
 5598			ec.Error(ctx, ec.Recover(ctx, r))
 5599			ret = graphql.Null
 5600		}
 5601	}()
 5602	fc := &graphql.FieldContext{
 5603		Object:   "Identity",
 5604		Field:    field,
 5605		Args:     nil,
 5606		IsMethod: true,
 5607	}
 5608
 5609	ctx = graphql.WithFieldContext(ctx, fc)
 5610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5611		ctx = rctx // use context from middleware stack in children
 5612		return ec.resolvers.Identity().ID(rctx, obj)
 5613	})
 5614	if err != nil {
 5615		ec.Error(ctx, err)
 5616		return graphql.Null
 5617	}
 5618	if resTmp == nil {
 5619		if !graphql.HasFieldError(ctx, fc) {
 5620			ec.Errorf(ctx, "must not be null")
 5621		}
 5622		return graphql.Null
 5623	}
 5624	res := resTmp.(string)
 5625	fc.Result = res
 5626	return ec.marshalNString2string(ctx, field.Selections, res)
 5627}
 5628
 5629func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5630	defer func() {
 5631		if r := recover(); r != nil {
 5632			ec.Error(ctx, ec.Recover(ctx, r))
 5633			ret = graphql.Null
 5634		}
 5635	}()
 5636	fc := &graphql.FieldContext{
 5637		Object:   "Identity",
 5638		Field:    field,
 5639		Args:     nil,
 5640		IsMethod: true,
 5641	}
 5642
 5643	ctx = graphql.WithFieldContext(ctx, fc)
 5644	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5645		ctx = rctx // use context from middleware stack in children
 5646		return ec.resolvers.Identity().HumanID(rctx, obj)
 5647	})
 5648	if err != nil {
 5649		ec.Error(ctx, err)
 5650		return graphql.Null
 5651	}
 5652	if resTmp == nil {
 5653		if !graphql.HasFieldError(ctx, fc) {
 5654			ec.Errorf(ctx, "must not be null")
 5655		}
 5656		return graphql.Null
 5657	}
 5658	res := resTmp.(string)
 5659	fc.Result = res
 5660	return ec.marshalNString2string(ctx, field.Selections, res)
 5661}
 5662
 5663func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5664	defer func() {
 5665		if r := recover(); r != nil {
 5666			ec.Error(ctx, ec.Recover(ctx, r))
 5667			ret = graphql.Null
 5668		}
 5669	}()
 5670	fc := &graphql.FieldContext{
 5671		Object:   "Identity",
 5672		Field:    field,
 5673		Args:     nil,
 5674		IsMethod: true,
 5675	}
 5676
 5677	ctx = graphql.WithFieldContext(ctx, fc)
 5678	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5679		ctx = rctx // use context from middleware stack in children
 5680		return obj.Name(), nil
 5681	})
 5682	if err != nil {
 5683		ec.Error(ctx, err)
 5684		return graphql.Null
 5685	}
 5686	if resTmp == nil {
 5687		return graphql.Null
 5688	}
 5689	res := resTmp.(string)
 5690	fc.Result = res
 5691	return ec.marshalOString2string(ctx, field.Selections, res)
 5692}
 5693
 5694func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5695	defer func() {
 5696		if r := recover(); r != nil {
 5697			ec.Error(ctx, ec.Recover(ctx, r))
 5698			ret = graphql.Null
 5699		}
 5700	}()
 5701	fc := &graphql.FieldContext{
 5702		Object:   "Identity",
 5703		Field:    field,
 5704		Args:     nil,
 5705		IsMethod: true,
 5706	}
 5707
 5708	ctx = graphql.WithFieldContext(ctx, fc)
 5709	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5710		ctx = rctx // use context from middleware stack in children
 5711		return obj.Email()
 5712	})
 5713	if err != nil {
 5714		ec.Error(ctx, err)
 5715		return graphql.Null
 5716	}
 5717	if resTmp == nil {
 5718		return graphql.Null
 5719	}
 5720	res := resTmp.(string)
 5721	fc.Result = res
 5722	return ec.marshalOString2string(ctx, field.Selections, res)
 5723}
 5724
 5725func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5726	defer func() {
 5727		if r := recover(); r != nil {
 5728			ec.Error(ctx, ec.Recover(ctx, r))
 5729			ret = graphql.Null
 5730		}
 5731	}()
 5732	fc := &graphql.FieldContext{
 5733		Object:   "Identity",
 5734		Field:    field,
 5735		Args:     nil,
 5736		IsMethod: true,
 5737	}
 5738
 5739	ctx = graphql.WithFieldContext(ctx, fc)
 5740	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5741		ctx = rctx // use context from middleware stack in children
 5742		return obj.Login()
 5743	})
 5744	if err != nil {
 5745		ec.Error(ctx, err)
 5746		return graphql.Null
 5747	}
 5748	if resTmp == nil {
 5749		return graphql.Null
 5750	}
 5751	res := resTmp.(string)
 5752	fc.Result = res
 5753	return ec.marshalOString2string(ctx, field.Selections, res)
 5754}
 5755
 5756func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5757	defer func() {
 5758		if r := recover(); r != nil {
 5759			ec.Error(ctx, ec.Recover(ctx, r))
 5760			ret = graphql.Null
 5761		}
 5762	}()
 5763	fc := &graphql.FieldContext{
 5764		Object:   "Identity",
 5765		Field:    field,
 5766		Args:     nil,
 5767		IsMethod: true,
 5768	}
 5769
 5770	ctx = graphql.WithFieldContext(ctx, fc)
 5771	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5772		ctx = rctx // use context from middleware stack in children
 5773		return obj.DisplayName(), nil
 5774	})
 5775	if err != nil {
 5776		ec.Error(ctx, err)
 5777		return graphql.Null
 5778	}
 5779	if resTmp == nil {
 5780		if !graphql.HasFieldError(ctx, fc) {
 5781			ec.Errorf(ctx, "must not be null")
 5782		}
 5783		return graphql.Null
 5784	}
 5785	res := resTmp.(string)
 5786	fc.Result = res
 5787	return ec.marshalNString2string(ctx, field.Selections, res)
 5788}
 5789
 5790func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5791	defer func() {
 5792		if r := recover(); r != nil {
 5793			ec.Error(ctx, ec.Recover(ctx, r))
 5794			ret = graphql.Null
 5795		}
 5796	}()
 5797	fc := &graphql.FieldContext{
 5798		Object:   "Identity",
 5799		Field:    field,
 5800		Args:     nil,
 5801		IsMethod: true,
 5802	}
 5803
 5804	ctx = graphql.WithFieldContext(ctx, fc)
 5805	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5806		ctx = rctx // use context from middleware stack in children
 5807		return obj.AvatarUrl()
 5808	})
 5809	if err != nil {
 5810		ec.Error(ctx, err)
 5811		return graphql.Null
 5812	}
 5813	if resTmp == nil {
 5814		return graphql.Null
 5815	}
 5816	res := resTmp.(string)
 5817	fc.Result = res
 5818	return ec.marshalOString2string(ctx, field.Selections, res)
 5819}
 5820
 5821func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5822	defer func() {
 5823		if r := recover(); r != nil {
 5824			ec.Error(ctx, ec.Recover(ctx, r))
 5825			ret = graphql.Null
 5826		}
 5827	}()
 5828	fc := &graphql.FieldContext{
 5829		Object:   "Identity",
 5830		Field:    field,
 5831		Args:     nil,
 5832		IsMethod: true,
 5833	}
 5834
 5835	ctx = graphql.WithFieldContext(ctx, fc)
 5836	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5837		ctx = rctx // use context from middleware stack in children
 5838		return obj.IsProtected()
 5839	})
 5840	if err != nil {
 5841		ec.Error(ctx, err)
 5842		return graphql.Null
 5843	}
 5844	if resTmp == nil {
 5845		if !graphql.HasFieldError(ctx, fc) {
 5846			ec.Errorf(ctx, "must not be null")
 5847		}
 5848		return graphql.Null
 5849	}
 5850	res := resTmp.(bool)
 5851	fc.Result = res
 5852	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5853}
 5854
 5855func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5856	defer func() {
 5857		if r := recover(); r != nil {
 5858			ec.Error(ctx, ec.Recover(ctx, r))
 5859			ret = graphql.Null
 5860		}
 5861	}()
 5862	fc := &graphql.FieldContext{
 5863		Object:   "IdentityConnection",
 5864		Field:    field,
 5865		Args:     nil,
 5866		IsMethod: false,
 5867	}
 5868
 5869	ctx = graphql.WithFieldContext(ctx, fc)
 5870	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5871		ctx = rctx // use context from middleware stack in children
 5872		return obj.Edges, nil
 5873	})
 5874	if err != nil {
 5875		ec.Error(ctx, err)
 5876		return graphql.Null
 5877	}
 5878	if resTmp == nil {
 5879		if !graphql.HasFieldError(ctx, fc) {
 5880			ec.Errorf(ctx, "must not be null")
 5881		}
 5882		return graphql.Null
 5883	}
 5884	res := resTmp.([]*models.IdentityEdge)
 5885	fc.Result = res
 5886	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 5887}
 5888
 5889func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5890	defer func() {
 5891		if r := recover(); r != nil {
 5892			ec.Error(ctx, ec.Recover(ctx, r))
 5893			ret = graphql.Null
 5894		}
 5895	}()
 5896	fc := &graphql.FieldContext{
 5897		Object:   "IdentityConnection",
 5898		Field:    field,
 5899		Args:     nil,
 5900		IsMethod: false,
 5901	}
 5902
 5903	ctx = graphql.WithFieldContext(ctx, fc)
 5904	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5905		ctx = rctx // use context from middleware stack in children
 5906		return obj.Nodes, nil
 5907	})
 5908	if err != nil {
 5909		ec.Error(ctx, err)
 5910		return graphql.Null
 5911	}
 5912	if resTmp == nil {
 5913		if !graphql.HasFieldError(ctx, fc) {
 5914			ec.Errorf(ctx, "must not be null")
 5915		}
 5916		return graphql.Null
 5917	}
 5918	res := resTmp.([]models.IdentityWrapper)
 5919	fc.Result = res
 5920	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
 5921}
 5922
 5923func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5924	defer func() {
 5925		if r := recover(); r != nil {
 5926			ec.Error(ctx, ec.Recover(ctx, r))
 5927			ret = graphql.Null
 5928		}
 5929	}()
 5930	fc := &graphql.FieldContext{
 5931		Object:   "IdentityConnection",
 5932		Field:    field,
 5933		Args:     nil,
 5934		IsMethod: false,
 5935	}
 5936
 5937	ctx = graphql.WithFieldContext(ctx, fc)
 5938	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5939		ctx = rctx // use context from middleware stack in children
 5940		return obj.PageInfo, nil
 5941	})
 5942	if err != nil {
 5943		ec.Error(ctx, err)
 5944		return graphql.Null
 5945	}
 5946	if resTmp == nil {
 5947		if !graphql.HasFieldError(ctx, fc) {
 5948			ec.Errorf(ctx, "must not be null")
 5949		}
 5950		return graphql.Null
 5951	}
 5952	res := resTmp.(*models.PageInfo)
 5953	fc.Result = res
 5954	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 5955}
 5956
 5957func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5958	defer func() {
 5959		if r := recover(); r != nil {
 5960			ec.Error(ctx, ec.Recover(ctx, r))
 5961			ret = graphql.Null
 5962		}
 5963	}()
 5964	fc := &graphql.FieldContext{
 5965		Object:   "IdentityConnection",
 5966		Field:    field,
 5967		Args:     nil,
 5968		IsMethod: false,
 5969	}
 5970
 5971	ctx = graphql.WithFieldContext(ctx, fc)
 5972	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5973		ctx = rctx // use context from middleware stack in children
 5974		return obj.TotalCount, nil
 5975	})
 5976	if err != nil {
 5977		ec.Error(ctx, err)
 5978		return graphql.Null
 5979	}
 5980	if resTmp == nil {
 5981		if !graphql.HasFieldError(ctx, fc) {
 5982			ec.Errorf(ctx, "must not be null")
 5983		}
 5984		return graphql.Null
 5985	}
 5986	res := resTmp.(int)
 5987	fc.Result = res
 5988	return ec.marshalNInt2int(ctx, field.Selections, res)
 5989}
 5990
 5991func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 5992	defer func() {
 5993		if r := recover(); r != nil {
 5994			ec.Error(ctx, ec.Recover(ctx, r))
 5995			ret = graphql.Null
 5996		}
 5997	}()
 5998	fc := &graphql.FieldContext{
 5999		Object:   "IdentityEdge",
 6000		Field:    field,
 6001		Args:     nil,
 6002		IsMethod: false,
 6003	}
 6004
 6005	ctx = graphql.WithFieldContext(ctx, fc)
 6006	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6007		ctx = rctx // use context from middleware stack in children
 6008		return obj.Cursor, nil
 6009	})
 6010	if err != nil {
 6011		ec.Error(ctx, err)
 6012		return graphql.Null
 6013	}
 6014	if resTmp == nil {
 6015		if !graphql.HasFieldError(ctx, fc) {
 6016			ec.Errorf(ctx, "must not be null")
 6017		}
 6018		return graphql.Null
 6019	}
 6020	res := resTmp.(string)
 6021	fc.Result = res
 6022	return ec.marshalNString2string(ctx, field.Selections, res)
 6023}
 6024
 6025func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6026	defer func() {
 6027		if r := recover(); r != nil {
 6028			ec.Error(ctx, ec.Recover(ctx, r))
 6029			ret = graphql.Null
 6030		}
 6031	}()
 6032	fc := &graphql.FieldContext{
 6033		Object:   "IdentityEdge",
 6034		Field:    field,
 6035		Args:     nil,
 6036		IsMethod: false,
 6037	}
 6038
 6039	ctx = graphql.WithFieldContext(ctx, fc)
 6040	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6041		ctx = rctx // use context from middleware stack in children
 6042		return obj.Node, nil
 6043	})
 6044	if err != nil {
 6045		ec.Error(ctx, err)
 6046		return graphql.Null
 6047	}
 6048	if resTmp == nil {
 6049		if !graphql.HasFieldError(ctx, fc) {
 6050			ec.Errorf(ctx, "must not be null")
 6051		}
 6052		return graphql.Null
 6053	}
 6054	res := resTmp.(models.IdentityWrapper)
 6055	fc.Result = res
 6056	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6057}
 6058
 6059func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6060	defer func() {
 6061		if r := recover(); r != nil {
 6062			ec.Error(ctx, ec.Recover(ctx, r))
 6063			ret = graphql.Null
 6064		}
 6065	}()
 6066	fc := &graphql.FieldContext{
 6067		Object:   "Label",
 6068		Field:    field,
 6069		Args:     nil,
 6070		IsMethod: true,
 6071	}
 6072
 6073	ctx = graphql.WithFieldContext(ctx, fc)
 6074	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6075		ctx = rctx // use context from middleware stack in children
 6076		return ec.resolvers.Label().Name(rctx, obj)
 6077	})
 6078	if err != nil {
 6079		ec.Error(ctx, err)
 6080		return graphql.Null
 6081	}
 6082	if resTmp == nil {
 6083		if !graphql.HasFieldError(ctx, fc) {
 6084			ec.Errorf(ctx, "must not be null")
 6085		}
 6086		return graphql.Null
 6087	}
 6088	res := resTmp.(string)
 6089	fc.Result = res
 6090	return ec.marshalNString2string(ctx, field.Selections, res)
 6091}
 6092
 6093func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6094	defer func() {
 6095		if r := recover(); r != nil {
 6096			ec.Error(ctx, ec.Recover(ctx, r))
 6097			ret = graphql.Null
 6098		}
 6099	}()
 6100	fc := &graphql.FieldContext{
 6101		Object:   "Label",
 6102		Field:    field,
 6103		Args:     nil,
 6104		IsMethod: true,
 6105	}
 6106
 6107	ctx = graphql.WithFieldContext(ctx, fc)
 6108	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6109		ctx = rctx // use context from middleware stack in children
 6110		return ec.resolvers.Label().Color(rctx, obj)
 6111	})
 6112	if err != nil {
 6113		ec.Error(ctx, err)
 6114		return graphql.Null
 6115	}
 6116	if resTmp == nil {
 6117		if !graphql.HasFieldError(ctx, fc) {
 6118			ec.Errorf(ctx, "must not be null")
 6119		}
 6120		return graphql.Null
 6121	}
 6122	res := resTmp.(*color.RGBA)
 6123	fc.Result = res
 6124	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6125}
 6126
 6127func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6128	defer func() {
 6129		if r := recover(); r != nil {
 6130			ec.Error(ctx, ec.Recover(ctx, r))
 6131			ret = graphql.Null
 6132		}
 6133	}()
 6134	fc := &graphql.FieldContext{
 6135		Object:   "LabelChangeOperation",
 6136		Field:    field,
 6137		Args:     nil,
 6138		IsMethod: true,
 6139	}
 6140
 6141	ctx = graphql.WithFieldContext(ctx, fc)
 6142	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6143		ctx = rctx // use context from middleware stack in children
 6144		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6145	})
 6146	if err != nil {
 6147		ec.Error(ctx, err)
 6148		return graphql.Null
 6149	}
 6150	if resTmp == nil {
 6151		if !graphql.HasFieldError(ctx, fc) {
 6152			ec.Errorf(ctx, "must not be null")
 6153		}
 6154		return graphql.Null
 6155	}
 6156	res := resTmp.(string)
 6157	fc.Result = res
 6158	return ec.marshalNString2string(ctx, field.Selections, res)
 6159}
 6160
 6161func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6162	defer func() {
 6163		if r := recover(); r != nil {
 6164			ec.Error(ctx, ec.Recover(ctx, r))
 6165			ret = graphql.Null
 6166		}
 6167	}()
 6168	fc := &graphql.FieldContext{
 6169		Object:   "LabelChangeOperation",
 6170		Field:    field,
 6171		Args:     nil,
 6172		IsMethod: true,
 6173	}
 6174
 6175	ctx = graphql.WithFieldContext(ctx, fc)
 6176	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6177		ctx = rctx // use context from middleware stack in children
 6178		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
 6179	})
 6180	if err != nil {
 6181		ec.Error(ctx, err)
 6182		return graphql.Null
 6183	}
 6184	if resTmp == nil {
 6185		if !graphql.HasFieldError(ctx, fc) {
 6186			ec.Errorf(ctx, "must not be null")
 6187		}
 6188		return graphql.Null
 6189	}
 6190	res := resTmp.(models.IdentityWrapper)
 6191	fc.Result = res
 6192	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6193}
 6194
 6195func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6196	defer func() {
 6197		if r := recover(); r != nil {
 6198			ec.Error(ctx, ec.Recover(ctx, r))
 6199			ret = graphql.Null
 6200		}
 6201	}()
 6202	fc := &graphql.FieldContext{
 6203		Object:   "LabelChangeOperation",
 6204		Field:    field,
 6205		Args:     nil,
 6206		IsMethod: true,
 6207	}
 6208
 6209	ctx = graphql.WithFieldContext(ctx, fc)
 6210	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6211		ctx = rctx // use context from middleware stack in children
 6212		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6213	})
 6214	if err != nil {
 6215		ec.Error(ctx, err)
 6216		return graphql.Null
 6217	}
 6218	if resTmp == nil {
 6219		if !graphql.HasFieldError(ctx, fc) {
 6220			ec.Errorf(ctx, "must not be null")
 6221		}
 6222		return graphql.Null
 6223	}
 6224	res := resTmp.(*time.Time)
 6225	fc.Result = res
 6226	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6227}
 6228
 6229func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6230	defer func() {
 6231		if r := recover(); r != nil {
 6232			ec.Error(ctx, ec.Recover(ctx, r))
 6233			ret = graphql.Null
 6234		}
 6235	}()
 6236	fc := &graphql.FieldContext{
 6237		Object:   "LabelChangeOperation",
 6238		Field:    field,
 6239		Args:     nil,
 6240		IsMethod: false,
 6241	}
 6242
 6243	ctx = graphql.WithFieldContext(ctx, fc)
 6244	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6245		ctx = rctx // use context from middleware stack in children
 6246		return obj.Added, nil
 6247	})
 6248	if err != nil {
 6249		ec.Error(ctx, err)
 6250		return graphql.Null
 6251	}
 6252	if resTmp == nil {
 6253		if !graphql.HasFieldError(ctx, fc) {
 6254			ec.Errorf(ctx, "must not be null")
 6255		}
 6256		return graphql.Null
 6257	}
 6258	res := resTmp.([]bug.Label)
 6259	fc.Result = res
 6260	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6261}
 6262
 6263func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6264	defer func() {
 6265		if r := recover(); r != nil {
 6266			ec.Error(ctx, ec.Recover(ctx, r))
 6267			ret = graphql.Null
 6268		}
 6269	}()
 6270	fc := &graphql.FieldContext{
 6271		Object:   "LabelChangeOperation",
 6272		Field:    field,
 6273		Args:     nil,
 6274		IsMethod: false,
 6275	}
 6276
 6277	ctx = graphql.WithFieldContext(ctx, fc)
 6278	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6279		ctx = rctx // use context from middleware stack in children
 6280		return obj.Removed, nil
 6281	})
 6282	if err != nil {
 6283		ec.Error(ctx, err)
 6284		return graphql.Null
 6285	}
 6286	if resTmp == nil {
 6287		if !graphql.HasFieldError(ctx, fc) {
 6288			ec.Errorf(ctx, "must not be null")
 6289		}
 6290		return graphql.Null
 6291	}
 6292	res := resTmp.([]bug.Label)
 6293	fc.Result = res
 6294	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6295}
 6296
 6297func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6298	defer func() {
 6299		if r := recover(); r != nil {
 6300			ec.Error(ctx, ec.Recover(ctx, r))
 6301			ret = graphql.Null
 6302		}
 6303	}()
 6304	fc := &graphql.FieldContext{
 6305		Object:   "LabelChangeResult",
 6306		Field:    field,
 6307		Args:     nil,
 6308		IsMethod: false,
 6309	}
 6310
 6311	ctx = graphql.WithFieldContext(ctx, fc)
 6312	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6313		ctx = rctx // use context from middleware stack in children
 6314		return obj.Label, nil
 6315	})
 6316	if err != nil {
 6317		ec.Error(ctx, err)
 6318		return graphql.Null
 6319	}
 6320	if resTmp == nil {
 6321		if !graphql.HasFieldError(ctx, fc) {
 6322			ec.Errorf(ctx, "must not be null")
 6323		}
 6324		return graphql.Null
 6325	}
 6326	res := resTmp.(bug.Label)
 6327	fc.Result = res
 6328	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6329}
 6330
 6331func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6332	defer func() {
 6333		if r := recover(); r != nil {
 6334			ec.Error(ctx, ec.Recover(ctx, r))
 6335			ret = graphql.Null
 6336		}
 6337	}()
 6338	fc := &graphql.FieldContext{
 6339		Object:   "LabelChangeResult",
 6340		Field:    field,
 6341		Args:     nil,
 6342		IsMethod: true,
 6343	}
 6344
 6345	ctx = graphql.WithFieldContext(ctx, fc)
 6346	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6347		ctx = rctx // use context from middleware stack in children
 6348		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6349	})
 6350	if err != nil {
 6351		ec.Error(ctx, err)
 6352		return graphql.Null
 6353	}
 6354	if resTmp == nil {
 6355		if !graphql.HasFieldError(ctx, fc) {
 6356			ec.Errorf(ctx, "must not be null")
 6357		}
 6358		return graphql.Null
 6359	}
 6360	res := resTmp.(models.LabelChangeStatus)
 6361	fc.Result = res
 6362	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6363}
 6364
 6365func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6366	defer func() {
 6367		if r := recover(); r != nil {
 6368			ec.Error(ctx, ec.Recover(ctx, r))
 6369			ret = graphql.Null
 6370		}
 6371	}()
 6372	fc := &graphql.FieldContext{
 6373		Object:   "LabelChangeTimelineItem",
 6374		Field:    field,
 6375		Args:     nil,
 6376		IsMethod: true,
 6377	}
 6378
 6379	ctx = graphql.WithFieldContext(ctx, fc)
 6380	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6381		ctx = rctx // use context from middleware stack in children
 6382		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6383	})
 6384	if err != nil {
 6385		ec.Error(ctx, err)
 6386		return graphql.Null
 6387	}
 6388	if resTmp == nil {
 6389		if !graphql.HasFieldError(ctx, fc) {
 6390			ec.Errorf(ctx, "must not be null")
 6391		}
 6392		return graphql.Null
 6393	}
 6394	res := resTmp.(string)
 6395	fc.Result = res
 6396	return ec.marshalNString2string(ctx, field.Selections, res)
 6397}
 6398
 6399func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6400	defer func() {
 6401		if r := recover(); r != nil {
 6402			ec.Error(ctx, ec.Recover(ctx, r))
 6403			ret = graphql.Null
 6404		}
 6405	}()
 6406	fc := &graphql.FieldContext{
 6407		Object:   "LabelChangeTimelineItem",
 6408		Field:    field,
 6409		Args:     nil,
 6410		IsMethod: true,
 6411	}
 6412
 6413	ctx = graphql.WithFieldContext(ctx, fc)
 6414	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6415		ctx = rctx // use context from middleware stack in children
 6416		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
 6417	})
 6418	if err != nil {
 6419		ec.Error(ctx, err)
 6420		return graphql.Null
 6421	}
 6422	if resTmp == nil {
 6423		if !graphql.HasFieldError(ctx, fc) {
 6424			ec.Errorf(ctx, "must not be null")
 6425		}
 6426		return graphql.Null
 6427	}
 6428	res := resTmp.(models.IdentityWrapper)
 6429	fc.Result = res
 6430	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6431}
 6432
 6433func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6434	defer func() {
 6435		if r := recover(); r != nil {
 6436			ec.Error(ctx, ec.Recover(ctx, r))
 6437			ret = graphql.Null
 6438		}
 6439	}()
 6440	fc := &graphql.FieldContext{
 6441		Object:   "LabelChangeTimelineItem",
 6442		Field:    field,
 6443		Args:     nil,
 6444		IsMethod: true,
 6445	}
 6446
 6447	ctx = graphql.WithFieldContext(ctx, fc)
 6448	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6449		ctx = rctx // use context from middleware stack in children
 6450		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6451	})
 6452	if err != nil {
 6453		ec.Error(ctx, err)
 6454		return graphql.Null
 6455	}
 6456	if resTmp == nil {
 6457		if !graphql.HasFieldError(ctx, fc) {
 6458			ec.Errorf(ctx, "must not be null")
 6459		}
 6460		return graphql.Null
 6461	}
 6462	res := resTmp.(*time.Time)
 6463	fc.Result = res
 6464	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6465}
 6466
 6467func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6468	defer func() {
 6469		if r := recover(); r != nil {
 6470			ec.Error(ctx, ec.Recover(ctx, r))
 6471			ret = graphql.Null
 6472		}
 6473	}()
 6474	fc := &graphql.FieldContext{
 6475		Object:   "LabelChangeTimelineItem",
 6476		Field:    field,
 6477		Args:     nil,
 6478		IsMethod: false,
 6479	}
 6480
 6481	ctx = graphql.WithFieldContext(ctx, fc)
 6482	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6483		ctx = rctx // use context from middleware stack in children
 6484		return obj.Added, nil
 6485	})
 6486	if err != nil {
 6487		ec.Error(ctx, err)
 6488		return graphql.Null
 6489	}
 6490	if resTmp == nil {
 6491		if !graphql.HasFieldError(ctx, fc) {
 6492			ec.Errorf(ctx, "must not be null")
 6493		}
 6494		return graphql.Null
 6495	}
 6496	res := resTmp.([]bug.Label)
 6497	fc.Result = res
 6498	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6499}
 6500
 6501func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6502	defer func() {
 6503		if r := recover(); r != nil {
 6504			ec.Error(ctx, ec.Recover(ctx, r))
 6505			ret = graphql.Null
 6506		}
 6507	}()
 6508	fc := &graphql.FieldContext{
 6509		Object:   "LabelChangeTimelineItem",
 6510		Field:    field,
 6511		Args:     nil,
 6512		IsMethod: false,
 6513	}
 6514
 6515	ctx = graphql.WithFieldContext(ctx, fc)
 6516	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6517		ctx = rctx // use context from middleware stack in children
 6518		return obj.Removed, nil
 6519	})
 6520	if err != nil {
 6521		ec.Error(ctx, err)
 6522		return graphql.Null
 6523	}
 6524	if resTmp == nil {
 6525		if !graphql.HasFieldError(ctx, fc) {
 6526			ec.Errorf(ctx, "must not be null")
 6527		}
 6528		return graphql.Null
 6529	}
 6530	res := resTmp.([]bug.Label)
 6531	fc.Result = res
 6532	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6533}
 6534
 6535func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6536	defer func() {
 6537		if r := recover(); r != nil {
 6538			ec.Error(ctx, ec.Recover(ctx, r))
 6539			ret = graphql.Null
 6540		}
 6541	}()
 6542	fc := &graphql.FieldContext{
 6543		Object:   "LabelConnection",
 6544		Field:    field,
 6545		Args:     nil,
 6546		IsMethod: false,
 6547	}
 6548
 6549	ctx = graphql.WithFieldContext(ctx, fc)
 6550	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6551		ctx = rctx // use context from middleware stack in children
 6552		return obj.Edges, nil
 6553	})
 6554	if err != nil {
 6555		ec.Error(ctx, err)
 6556		return graphql.Null
 6557	}
 6558	if resTmp == nil {
 6559		if !graphql.HasFieldError(ctx, fc) {
 6560			ec.Errorf(ctx, "must not be null")
 6561		}
 6562		return graphql.Null
 6563	}
 6564	res := resTmp.([]*models.LabelEdge)
 6565	fc.Result = res
 6566	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 6567}
 6568
 6569func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6570	defer func() {
 6571		if r := recover(); r != nil {
 6572			ec.Error(ctx, ec.Recover(ctx, r))
 6573			ret = graphql.Null
 6574		}
 6575	}()
 6576	fc := &graphql.FieldContext{
 6577		Object:   "LabelConnection",
 6578		Field:    field,
 6579		Args:     nil,
 6580		IsMethod: false,
 6581	}
 6582
 6583	ctx = graphql.WithFieldContext(ctx, fc)
 6584	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6585		ctx = rctx // use context from middleware stack in children
 6586		return obj.Nodes, nil
 6587	})
 6588	if err != nil {
 6589		ec.Error(ctx, err)
 6590		return graphql.Null
 6591	}
 6592	if resTmp == nil {
 6593		if !graphql.HasFieldError(ctx, fc) {
 6594			ec.Errorf(ctx, "must not be null")
 6595		}
 6596		return graphql.Null
 6597	}
 6598	res := resTmp.([]bug.Label)
 6599	fc.Result = res
 6600	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6601}
 6602
 6603func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6604	defer func() {
 6605		if r := recover(); r != nil {
 6606			ec.Error(ctx, ec.Recover(ctx, r))
 6607			ret = graphql.Null
 6608		}
 6609	}()
 6610	fc := &graphql.FieldContext{
 6611		Object:   "LabelConnection",
 6612		Field:    field,
 6613		Args:     nil,
 6614		IsMethod: false,
 6615	}
 6616
 6617	ctx = graphql.WithFieldContext(ctx, fc)
 6618	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6619		ctx = rctx // use context from middleware stack in children
 6620		return obj.PageInfo, nil
 6621	})
 6622	if err != nil {
 6623		ec.Error(ctx, err)
 6624		return graphql.Null
 6625	}
 6626	if resTmp == nil {
 6627		if !graphql.HasFieldError(ctx, fc) {
 6628			ec.Errorf(ctx, "must not be null")
 6629		}
 6630		return graphql.Null
 6631	}
 6632	res := resTmp.(*models.PageInfo)
 6633	fc.Result = res
 6634	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6635}
 6636
 6637func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6638	defer func() {
 6639		if r := recover(); r != nil {
 6640			ec.Error(ctx, ec.Recover(ctx, r))
 6641			ret = graphql.Null
 6642		}
 6643	}()
 6644	fc := &graphql.FieldContext{
 6645		Object:   "LabelConnection",
 6646		Field:    field,
 6647		Args:     nil,
 6648		IsMethod: false,
 6649	}
 6650
 6651	ctx = graphql.WithFieldContext(ctx, fc)
 6652	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6653		ctx = rctx // use context from middleware stack in children
 6654		return obj.TotalCount, nil
 6655	})
 6656	if err != nil {
 6657		ec.Error(ctx, err)
 6658		return graphql.Null
 6659	}
 6660	if resTmp == nil {
 6661		if !graphql.HasFieldError(ctx, fc) {
 6662			ec.Errorf(ctx, "must not be null")
 6663		}
 6664		return graphql.Null
 6665	}
 6666	res := resTmp.(int)
 6667	fc.Result = res
 6668	return ec.marshalNInt2int(ctx, field.Selections, res)
 6669}
 6670
 6671func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6672	defer func() {
 6673		if r := recover(); r != nil {
 6674			ec.Error(ctx, ec.Recover(ctx, r))
 6675			ret = graphql.Null
 6676		}
 6677	}()
 6678	fc := &graphql.FieldContext{
 6679		Object:   "LabelEdge",
 6680		Field:    field,
 6681		Args:     nil,
 6682		IsMethod: false,
 6683	}
 6684
 6685	ctx = graphql.WithFieldContext(ctx, fc)
 6686	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6687		ctx = rctx // use context from middleware stack in children
 6688		return obj.Cursor, nil
 6689	})
 6690	if err != nil {
 6691		ec.Error(ctx, err)
 6692		return graphql.Null
 6693	}
 6694	if resTmp == nil {
 6695		if !graphql.HasFieldError(ctx, fc) {
 6696			ec.Errorf(ctx, "must not be null")
 6697		}
 6698		return graphql.Null
 6699	}
 6700	res := resTmp.(string)
 6701	fc.Result = res
 6702	return ec.marshalNString2string(ctx, field.Selections, res)
 6703}
 6704
 6705func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6706	defer func() {
 6707		if r := recover(); r != nil {
 6708			ec.Error(ctx, ec.Recover(ctx, r))
 6709			ret = graphql.Null
 6710		}
 6711	}()
 6712	fc := &graphql.FieldContext{
 6713		Object:   "LabelEdge",
 6714		Field:    field,
 6715		Args:     nil,
 6716		IsMethod: false,
 6717	}
 6718
 6719	ctx = graphql.WithFieldContext(ctx, fc)
 6720	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6721		ctx = rctx // use context from middleware stack in children
 6722		return obj.Node, nil
 6723	})
 6724	if err != nil {
 6725		ec.Error(ctx, err)
 6726		return graphql.Null
 6727	}
 6728	if resTmp == nil {
 6729		if !graphql.HasFieldError(ctx, fc) {
 6730			ec.Errorf(ctx, "must not be null")
 6731		}
 6732		return graphql.Null
 6733	}
 6734	res := resTmp.(bug.Label)
 6735	fc.Result = res
 6736	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6737}
 6738
 6739func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6740	defer func() {
 6741		if r := recover(); r != nil {
 6742			ec.Error(ctx, ec.Recover(ctx, r))
 6743			ret = graphql.Null
 6744		}
 6745	}()
 6746	fc := &graphql.FieldContext{
 6747		Object:   "Mutation",
 6748		Field:    field,
 6749		Args:     nil,
 6750		IsMethod: true,
 6751	}
 6752
 6753	ctx = graphql.WithFieldContext(ctx, fc)
 6754	rawArgs := field.ArgumentMap(ec.Variables)
 6755	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6756	if err != nil {
 6757		ec.Error(ctx, err)
 6758		return graphql.Null
 6759	}
 6760	fc.Args = args
 6761	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6762		ctx = rctx // use context from middleware stack in children
 6763		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 6764	})
 6765	if err != nil {
 6766		ec.Error(ctx, err)
 6767		return graphql.Null
 6768	}
 6769	if resTmp == nil {
 6770		if !graphql.HasFieldError(ctx, fc) {
 6771			ec.Errorf(ctx, "must not be null")
 6772		}
 6773		return graphql.Null
 6774	}
 6775	res := resTmp.(*models.NewBugPayload)
 6776	fc.Result = res
 6777	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 6778}
 6779
 6780func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6781	defer func() {
 6782		if r := recover(); r != nil {
 6783			ec.Error(ctx, ec.Recover(ctx, r))
 6784			ret = graphql.Null
 6785		}
 6786	}()
 6787	fc := &graphql.FieldContext{
 6788		Object:   "Mutation",
 6789		Field:    field,
 6790		Args:     nil,
 6791		IsMethod: true,
 6792	}
 6793
 6794	ctx = graphql.WithFieldContext(ctx, fc)
 6795	rawArgs := field.ArgumentMap(ec.Variables)
 6796	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 6797	if err != nil {
 6798		ec.Error(ctx, err)
 6799		return graphql.Null
 6800	}
 6801	fc.Args = args
 6802	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6803		ctx = rctx // use context from middleware stack in children
 6804		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 6805	})
 6806	if err != nil {
 6807		ec.Error(ctx, err)
 6808		return graphql.Null
 6809	}
 6810	if resTmp == nil {
 6811		if !graphql.HasFieldError(ctx, fc) {
 6812			ec.Errorf(ctx, "must not be null")
 6813		}
 6814		return graphql.Null
 6815	}
 6816	res := resTmp.(*models.AddCommentPayload)
 6817	fc.Result = res
 6818	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 6819}
 6820
 6821func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6822	defer func() {
 6823		if r := recover(); r != nil {
 6824			ec.Error(ctx, ec.Recover(ctx, r))
 6825			ret = graphql.Null
 6826		}
 6827	}()
 6828	fc := &graphql.FieldContext{
 6829		Object:   "Mutation",
 6830		Field:    field,
 6831		Args:     nil,
 6832		IsMethod: true,
 6833	}
 6834
 6835	ctx = graphql.WithFieldContext(ctx, fc)
 6836	rawArgs := field.ArgumentMap(ec.Variables)
 6837	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 6838	if err != nil {
 6839		ec.Error(ctx, err)
 6840		return graphql.Null
 6841	}
 6842	fc.Args = args
 6843	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6844		ctx = rctx // use context from middleware stack in children
 6845		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 6846	})
 6847	if err != nil {
 6848		ec.Error(ctx, err)
 6849		return graphql.Null
 6850	}
 6851	if resTmp == nil {
 6852		if !graphql.HasFieldError(ctx, fc) {
 6853			ec.Errorf(ctx, "must not be null")
 6854		}
 6855		return graphql.Null
 6856	}
 6857	res := resTmp.(*models.ChangeLabelPayload)
 6858	fc.Result = res
 6859	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 6860}
 6861
 6862func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6863	defer func() {
 6864		if r := recover(); r != nil {
 6865			ec.Error(ctx, ec.Recover(ctx, r))
 6866			ret = graphql.Null
 6867		}
 6868	}()
 6869	fc := &graphql.FieldContext{
 6870		Object:   "Mutation",
 6871		Field:    field,
 6872		Args:     nil,
 6873		IsMethod: true,
 6874	}
 6875
 6876	ctx = graphql.WithFieldContext(ctx, fc)
 6877	rawArgs := field.ArgumentMap(ec.Variables)
 6878	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 6879	if err != nil {
 6880		ec.Error(ctx, err)
 6881		return graphql.Null
 6882	}
 6883	fc.Args = args
 6884	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6885		ctx = rctx // use context from middleware stack in children
 6886		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 6887	})
 6888	if err != nil {
 6889		ec.Error(ctx, err)
 6890		return graphql.Null
 6891	}
 6892	if resTmp == nil {
 6893		if !graphql.HasFieldError(ctx, fc) {
 6894			ec.Errorf(ctx, "must not be null")
 6895		}
 6896		return graphql.Null
 6897	}
 6898	res := resTmp.(*models.OpenBugPayload)
 6899	fc.Result = res
 6900	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 6901}
 6902
 6903func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6904	defer func() {
 6905		if r := recover(); r != nil {
 6906			ec.Error(ctx, ec.Recover(ctx, r))
 6907			ret = graphql.Null
 6908		}
 6909	}()
 6910	fc := &graphql.FieldContext{
 6911		Object:   "Mutation",
 6912		Field:    field,
 6913		Args:     nil,
 6914		IsMethod: true,
 6915	}
 6916
 6917	ctx = graphql.WithFieldContext(ctx, fc)
 6918	rawArgs := field.ArgumentMap(ec.Variables)
 6919	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 6920	if err != nil {
 6921		ec.Error(ctx, err)
 6922		return graphql.Null
 6923	}
 6924	fc.Args = args
 6925	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6926		ctx = rctx // use context from middleware stack in children
 6927		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 6928	})
 6929	if err != nil {
 6930		ec.Error(ctx, err)
 6931		return graphql.Null
 6932	}
 6933	if resTmp == nil {
 6934		if !graphql.HasFieldError(ctx, fc) {
 6935			ec.Errorf(ctx, "must not be null")
 6936		}
 6937		return graphql.Null
 6938	}
 6939	res := resTmp.(*models.CloseBugPayload)
 6940	fc.Result = res
 6941	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 6942}
 6943
 6944func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6945	defer func() {
 6946		if r := recover(); r != nil {
 6947			ec.Error(ctx, ec.Recover(ctx, r))
 6948			ret = graphql.Null
 6949		}
 6950	}()
 6951	fc := &graphql.FieldContext{
 6952		Object:   "Mutation",
 6953		Field:    field,
 6954		Args:     nil,
 6955		IsMethod: true,
 6956	}
 6957
 6958	ctx = graphql.WithFieldContext(ctx, fc)
 6959	rawArgs := field.ArgumentMap(ec.Variables)
 6960	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 6961	if err != nil {
 6962		ec.Error(ctx, err)
 6963		return graphql.Null
 6964	}
 6965	fc.Args = args
 6966	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6967		ctx = rctx // use context from middleware stack in children
 6968		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 6969	})
 6970	if err != nil {
 6971		ec.Error(ctx, err)
 6972		return graphql.Null
 6973	}
 6974	if resTmp == nil {
 6975		if !graphql.HasFieldError(ctx, fc) {
 6976			ec.Errorf(ctx, "must not be null")
 6977		}
 6978		return graphql.Null
 6979	}
 6980	res := resTmp.(*models.SetTitlePayload)
 6981	fc.Result = res
 6982	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 6983}
 6984
 6985func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 6986	defer func() {
 6987		if r := recover(); r != nil {
 6988			ec.Error(ctx, ec.Recover(ctx, r))
 6989			ret = graphql.Null
 6990		}
 6991	}()
 6992	fc := &graphql.FieldContext{
 6993		Object:   "NewBugPayload",
 6994		Field:    field,
 6995		Args:     nil,
 6996		IsMethod: false,
 6997	}
 6998
 6999	ctx = graphql.WithFieldContext(ctx, fc)
 7000	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7001		ctx = rctx // use context from middleware stack in children
 7002		return obj.ClientMutationID, nil
 7003	})
 7004	if err != nil {
 7005		ec.Error(ctx, err)
 7006		return graphql.Null
 7007	}
 7008	if resTmp == nil {
 7009		return graphql.Null
 7010	}
 7011	res := resTmp.(*string)
 7012	fc.Result = res
 7013	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7014}
 7015
 7016func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7017	defer func() {
 7018		if r := recover(); r != nil {
 7019			ec.Error(ctx, ec.Recover(ctx, r))
 7020			ret = graphql.Null
 7021		}
 7022	}()
 7023	fc := &graphql.FieldContext{
 7024		Object:   "NewBugPayload",
 7025		Field:    field,
 7026		Args:     nil,
 7027		IsMethod: false,
 7028	}
 7029
 7030	ctx = graphql.WithFieldContext(ctx, fc)
 7031	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7032		ctx = rctx // use context from middleware stack in children
 7033		return obj.Bug, nil
 7034	})
 7035	if err != nil {
 7036		ec.Error(ctx, err)
 7037		return graphql.Null
 7038	}
 7039	if resTmp == nil {
 7040		if !graphql.HasFieldError(ctx, fc) {
 7041			ec.Errorf(ctx, "must not be null")
 7042		}
 7043		return graphql.Null
 7044	}
 7045	res := resTmp.(models.BugWrapper)
 7046	fc.Result = res
 7047	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7048}
 7049
 7050func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7051	defer func() {
 7052		if r := recover(); r != nil {
 7053			ec.Error(ctx, ec.Recover(ctx, r))
 7054			ret = graphql.Null
 7055		}
 7056	}()
 7057	fc := &graphql.FieldContext{
 7058		Object:   "NewBugPayload",
 7059		Field:    field,
 7060		Args:     nil,
 7061		IsMethod: false,
 7062	}
 7063
 7064	ctx = graphql.WithFieldContext(ctx, fc)
 7065	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7066		ctx = rctx // use context from middleware stack in children
 7067		return obj.Operation, nil
 7068	})
 7069	if err != nil {
 7070		ec.Error(ctx, err)
 7071		return graphql.Null
 7072	}
 7073	if resTmp == nil {
 7074		if !graphql.HasFieldError(ctx, fc) {
 7075			ec.Errorf(ctx, "must not be null")
 7076		}
 7077		return graphql.Null
 7078	}
 7079	res := resTmp.(*bug.CreateOperation)
 7080	fc.Result = res
 7081	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7082}
 7083
 7084func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7085	defer func() {
 7086		if r := recover(); r != nil {
 7087			ec.Error(ctx, ec.Recover(ctx, r))
 7088			ret = graphql.Null
 7089		}
 7090	}()
 7091	fc := &graphql.FieldContext{
 7092		Object:   "OpenBugPayload",
 7093		Field:    field,
 7094		Args:     nil,
 7095		IsMethod: false,
 7096	}
 7097
 7098	ctx = graphql.WithFieldContext(ctx, fc)
 7099	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7100		ctx = rctx // use context from middleware stack in children
 7101		return obj.ClientMutationID, nil
 7102	})
 7103	if err != nil {
 7104		ec.Error(ctx, err)
 7105		return graphql.Null
 7106	}
 7107	if resTmp == nil {
 7108		return graphql.Null
 7109	}
 7110	res := resTmp.(*string)
 7111	fc.Result = res
 7112	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7113}
 7114
 7115func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7116	defer func() {
 7117		if r := recover(); r != nil {
 7118			ec.Error(ctx, ec.Recover(ctx, r))
 7119			ret = graphql.Null
 7120		}
 7121	}()
 7122	fc := &graphql.FieldContext{
 7123		Object:   "OpenBugPayload",
 7124		Field:    field,
 7125		Args:     nil,
 7126		IsMethod: false,
 7127	}
 7128
 7129	ctx = graphql.WithFieldContext(ctx, fc)
 7130	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7131		ctx = rctx // use context from middleware stack in children
 7132		return obj.Bug, nil
 7133	})
 7134	if err != nil {
 7135		ec.Error(ctx, err)
 7136		return graphql.Null
 7137	}
 7138	if resTmp == nil {
 7139		if !graphql.HasFieldError(ctx, fc) {
 7140			ec.Errorf(ctx, "must not be null")
 7141		}
 7142		return graphql.Null
 7143	}
 7144	res := resTmp.(models.BugWrapper)
 7145	fc.Result = res
 7146	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7147}
 7148
 7149func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7150	defer func() {
 7151		if r := recover(); r != nil {
 7152			ec.Error(ctx, ec.Recover(ctx, r))
 7153			ret = graphql.Null
 7154		}
 7155	}()
 7156	fc := &graphql.FieldContext{
 7157		Object:   "OpenBugPayload",
 7158		Field:    field,
 7159		Args:     nil,
 7160		IsMethod: false,
 7161	}
 7162
 7163	ctx = graphql.WithFieldContext(ctx, fc)
 7164	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7165		ctx = rctx // use context from middleware stack in children
 7166		return obj.Operation, nil
 7167	})
 7168	if err != nil {
 7169		ec.Error(ctx, err)
 7170		return graphql.Null
 7171	}
 7172	if resTmp == nil {
 7173		if !graphql.HasFieldError(ctx, fc) {
 7174			ec.Errorf(ctx, "must not be null")
 7175		}
 7176		return graphql.Null
 7177	}
 7178	res := resTmp.(*bug.SetStatusOperation)
 7179	fc.Result = res
 7180	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7181}
 7182
 7183func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7184	defer func() {
 7185		if r := recover(); r != nil {
 7186			ec.Error(ctx, ec.Recover(ctx, r))
 7187			ret = graphql.Null
 7188		}
 7189	}()
 7190	fc := &graphql.FieldContext{
 7191		Object:   "OperationConnection",
 7192		Field:    field,
 7193		Args:     nil,
 7194		IsMethod: false,
 7195	}
 7196
 7197	ctx = graphql.WithFieldContext(ctx, fc)
 7198	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7199		ctx = rctx // use context from middleware stack in children
 7200		return obj.Edges, nil
 7201	})
 7202	if err != nil {
 7203		ec.Error(ctx, err)
 7204		return graphql.Null
 7205	}
 7206	if resTmp == nil {
 7207		if !graphql.HasFieldError(ctx, fc) {
 7208			ec.Errorf(ctx, "must not be null")
 7209		}
 7210		return graphql.Null
 7211	}
 7212	res := resTmp.([]*models.OperationEdge)
 7213	fc.Result = res
 7214	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7215}
 7216
 7217func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7218	defer func() {
 7219		if r := recover(); r != nil {
 7220			ec.Error(ctx, ec.Recover(ctx, r))
 7221			ret = graphql.Null
 7222		}
 7223	}()
 7224	fc := &graphql.FieldContext{
 7225		Object:   "OperationConnection",
 7226		Field:    field,
 7227		Args:     nil,
 7228		IsMethod: false,
 7229	}
 7230
 7231	ctx = graphql.WithFieldContext(ctx, fc)
 7232	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7233		ctx = rctx // use context from middleware stack in children
 7234		return obj.Nodes, nil
 7235	})
 7236	if err != nil {
 7237		ec.Error(ctx, err)
 7238		return graphql.Null
 7239	}
 7240	if resTmp == nil {
 7241		if !graphql.HasFieldError(ctx, fc) {
 7242			ec.Errorf(ctx, "must not be null")
 7243		}
 7244		return graphql.Null
 7245	}
 7246	res := resTmp.([]bug.Operation)
 7247	fc.Result = res
 7248	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7249}
 7250
 7251func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7252	defer func() {
 7253		if r := recover(); r != nil {
 7254			ec.Error(ctx, ec.Recover(ctx, r))
 7255			ret = graphql.Null
 7256		}
 7257	}()
 7258	fc := &graphql.FieldContext{
 7259		Object:   "OperationConnection",
 7260		Field:    field,
 7261		Args:     nil,
 7262		IsMethod: false,
 7263	}
 7264
 7265	ctx = graphql.WithFieldContext(ctx, fc)
 7266	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7267		ctx = rctx // use context from middleware stack in children
 7268		return obj.PageInfo, nil
 7269	})
 7270	if err != nil {
 7271		ec.Error(ctx, err)
 7272		return graphql.Null
 7273	}
 7274	if resTmp == nil {
 7275		if !graphql.HasFieldError(ctx, fc) {
 7276			ec.Errorf(ctx, "must not be null")
 7277		}
 7278		return graphql.Null
 7279	}
 7280	res := resTmp.(*models.PageInfo)
 7281	fc.Result = res
 7282	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7283}
 7284
 7285func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7286	defer func() {
 7287		if r := recover(); r != nil {
 7288			ec.Error(ctx, ec.Recover(ctx, r))
 7289			ret = graphql.Null
 7290		}
 7291	}()
 7292	fc := &graphql.FieldContext{
 7293		Object:   "OperationConnection",
 7294		Field:    field,
 7295		Args:     nil,
 7296		IsMethod: false,
 7297	}
 7298
 7299	ctx = graphql.WithFieldContext(ctx, fc)
 7300	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7301		ctx = rctx // use context from middleware stack in children
 7302		return obj.TotalCount, nil
 7303	})
 7304	if err != nil {
 7305		ec.Error(ctx, err)
 7306		return graphql.Null
 7307	}
 7308	if resTmp == nil {
 7309		if !graphql.HasFieldError(ctx, fc) {
 7310			ec.Errorf(ctx, "must not be null")
 7311		}
 7312		return graphql.Null
 7313	}
 7314	res := resTmp.(int)
 7315	fc.Result = res
 7316	return ec.marshalNInt2int(ctx, field.Selections, res)
 7317}
 7318
 7319func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7320	defer func() {
 7321		if r := recover(); r != nil {
 7322			ec.Error(ctx, ec.Recover(ctx, r))
 7323			ret = graphql.Null
 7324		}
 7325	}()
 7326	fc := &graphql.FieldContext{
 7327		Object:   "OperationEdge",
 7328		Field:    field,
 7329		Args:     nil,
 7330		IsMethod: false,
 7331	}
 7332
 7333	ctx = graphql.WithFieldContext(ctx, fc)
 7334	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7335		ctx = rctx // use context from middleware stack in children
 7336		return obj.Cursor, nil
 7337	})
 7338	if err != nil {
 7339		ec.Error(ctx, err)
 7340		return graphql.Null
 7341	}
 7342	if resTmp == nil {
 7343		if !graphql.HasFieldError(ctx, fc) {
 7344			ec.Errorf(ctx, "must not be null")
 7345		}
 7346		return graphql.Null
 7347	}
 7348	res := resTmp.(string)
 7349	fc.Result = res
 7350	return ec.marshalNString2string(ctx, field.Selections, res)
 7351}
 7352
 7353func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7354	defer func() {
 7355		if r := recover(); r != nil {
 7356			ec.Error(ctx, ec.Recover(ctx, r))
 7357			ret = graphql.Null
 7358		}
 7359	}()
 7360	fc := &graphql.FieldContext{
 7361		Object:   "OperationEdge",
 7362		Field:    field,
 7363		Args:     nil,
 7364		IsMethod: false,
 7365	}
 7366
 7367	ctx = graphql.WithFieldContext(ctx, fc)
 7368	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7369		ctx = rctx // use context from middleware stack in children
 7370		return obj.Node, nil
 7371	})
 7372	if err != nil {
 7373		ec.Error(ctx, err)
 7374		return graphql.Null
 7375	}
 7376	if resTmp == nil {
 7377		if !graphql.HasFieldError(ctx, fc) {
 7378			ec.Errorf(ctx, "must not be null")
 7379		}
 7380		return graphql.Null
 7381	}
 7382	res := resTmp.(bug.Operation)
 7383	fc.Result = res
 7384	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7385}
 7386
 7387func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7388	defer func() {
 7389		if r := recover(); r != nil {
 7390			ec.Error(ctx, ec.Recover(ctx, r))
 7391			ret = graphql.Null
 7392		}
 7393	}()
 7394	fc := &graphql.FieldContext{
 7395		Object:   "PageInfo",
 7396		Field:    field,
 7397		Args:     nil,
 7398		IsMethod: false,
 7399	}
 7400
 7401	ctx = graphql.WithFieldContext(ctx, fc)
 7402	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7403		ctx = rctx // use context from middleware stack in children
 7404		return obj.HasNextPage, nil
 7405	})
 7406	if err != nil {
 7407		ec.Error(ctx, err)
 7408		return graphql.Null
 7409	}
 7410	if resTmp == nil {
 7411		if !graphql.HasFieldError(ctx, fc) {
 7412			ec.Errorf(ctx, "must not be null")
 7413		}
 7414		return graphql.Null
 7415	}
 7416	res := resTmp.(bool)
 7417	fc.Result = res
 7418	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7419}
 7420
 7421func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7422	defer func() {
 7423		if r := recover(); r != nil {
 7424			ec.Error(ctx, ec.Recover(ctx, r))
 7425			ret = graphql.Null
 7426		}
 7427	}()
 7428	fc := &graphql.FieldContext{
 7429		Object:   "PageInfo",
 7430		Field:    field,
 7431		Args:     nil,
 7432		IsMethod: false,
 7433	}
 7434
 7435	ctx = graphql.WithFieldContext(ctx, fc)
 7436	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7437		ctx = rctx // use context from middleware stack in children
 7438		return obj.HasPreviousPage, nil
 7439	})
 7440	if err != nil {
 7441		ec.Error(ctx, err)
 7442		return graphql.Null
 7443	}
 7444	if resTmp == nil {
 7445		if !graphql.HasFieldError(ctx, fc) {
 7446			ec.Errorf(ctx, "must not be null")
 7447		}
 7448		return graphql.Null
 7449	}
 7450	res := resTmp.(bool)
 7451	fc.Result = res
 7452	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7453}
 7454
 7455func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7456	defer func() {
 7457		if r := recover(); r != nil {
 7458			ec.Error(ctx, ec.Recover(ctx, r))
 7459			ret = graphql.Null
 7460		}
 7461	}()
 7462	fc := &graphql.FieldContext{
 7463		Object:   "PageInfo",
 7464		Field:    field,
 7465		Args:     nil,
 7466		IsMethod: false,
 7467	}
 7468
 7469	ctx = graphql.WithFieldContext(ctx, fc)
 7470	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7471		ctx = rctx // use context from middleware stack in children
 7472		return obj.StartCursor, nil
 7473	})
 7474	if err != nil {
 7475		ec.Error(ctx, err)
 7476		return graphql.Null
 7477	}
 7478	if resTmp == nil {
 7479		if !graphql.HasFieldError(ctx, fc) {
 7480			ec.Errorf(ctx, "must not be null")
 7481		}
 7482		return graphql.Null
 7483	}
 7484	res := resTmp.(string)
 7485	fc.Result = res
 7486	return ec.marshalNString2string(ctx, field.Selections, res)
 7487}
 7488
 7489func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7490	defer func() {
 7491		if r := recover(); r != nil {
 7492			ec.Error(ctx, ec.Recover(ctx, r))
 7493			ret = graphql.Null
 7494		}
 7495	}()
 7496	fc := &graphql.FieldContext{
 7497		Object:   "PageInfo",
 7498		Field:    field,
 7499		Args:     nil,
 7500		IsMethod: false,
 7501	}
 7502
 7503	ctx = graphql.WithFieldContext(ctx, fc)
 7504	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7505		ctx = rctx // use context from middleware stack in children
 7506		return obj.EndCursor, nil
 7507	})
 7508	if err != nil {
 7509		ec.Error(ctx, err)
 7510		return graphql.Null
 7511	}
 7512	if resTmp == nil {
 7513		if !graphql.HasFieldError(ctx, fc) {
 7514			ec.Errorf(ctx, "must not be null")
 7515		}
 7516		return graphql.Null
 7517	}
 7518	res := resTmp.(string)
 7519	fc.Result = res
 7520	return ec.marshalNString2string(ctx, field.Selections, res)
 7521}
 7522
 7523func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7524	defer func() {
 7525		if r := recover(); r != nil {
 7526			ec.Error(ctx, ec.Recover(ctx, r))
 7527			ret = graphql.Null
 7528		}
 7529	}()
 7530	fc := &graphql.FieldContext{
 7531		Object:   "Query",
 7532		Field:    field,
 7533		Args:     nil,
 7534		IsMethod: true,
 7535	}
 7536
 7537	ctx = graphql.WithFieldContext(ctx, fc)
 7538	rawArgs := field.ArgumentMap(ec.Variables)
 7539	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7540	if err != nil {
 7541		ec.Error(ctx, err)
 7542		return graphql.Null
 7543	}
 7544	fc.Args = args
 7545	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7546		ctx = rctx // use context from middleware stack in children
 7547		return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
 7548	})
 7549	if err != nil {
 7550		ec.Error(ctx, err)
 7551		return graphql.Null
 7552	}
 7553	if resTmp == nil {
 7554		return graphql.Null
 7555	}
 7556	res := resTmp.(*models.Repository)
 7557	fc.Result = res
 7558	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7559}
 7560
 7561func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7562	defer func() {
 7563		if r := recover(); r != nil {
 7564			ec.Error(ctx, ec.Recover(ctx, r))
 7565			ret = graphql.Null
 7566		}
 7567	}()
 7568	fc := &graphql.FieldContext{
 7569		Object:   "Query",
 7570		Field:    field,
 7571		Args:     nil,
 7572		IsMethod: true,
 7573	}
 7574
 7575	ctx = graphql.WithFieldContext(ctx, fc)
 7576	rawArgs := field.ArgumentMap(ec.Variables)
 7577	args, err := ec.field_Query___type_args(ctx, rawArgs)
 7578	if err != nil {
 7579		ec.Error(ctx, err)
 7580		return graphql.Null
 7581	}
 7582	fc.Args = args
 7583	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7584		ctx = rctx // use context from middleware stack in children
 7585		return ec.introspectType(args["name"].(string))
 7586	})
 7587	if err != nil {
 7588		ec.Error(ctx, err)
 7589		return graphql.Null
 7590	}
 7591	if resTmp == nil {
 7592		return graphql.Null
 7593	}
 7594	res := resTmp.(*introspection.Type)
 7595	fc.Result = res
 7596	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7597}
 7598
 7599func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7600	defer func() {
 7601		if r := recover(); r != nil {
 7602			ec.Error(ctx, ec.Recover(ctx, r))
 7603			ret = graphql.Null
 7604		}
 7605	}()
 7606	fc := &graphql.FieldContext{
 7607		Object:   "Query",
 7608		Field:    field,
 7609		Args:     nil,
 7610		IsMethod: true,
 7611	}
 7612
 7613	ctx = graphql.WithFieldContext(ctx, fc)
 7614	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7615		ctx = rctx // use context from middleware stack in children
 7616		return ec.introspectSchema()
 7617	})
 7618	if err != nil {
 7619		ec.Error(ctx, err)
 7620		return graphql.Null
 7621	}
 7622	if resTmp == nil {
 7623		return graphql.Null
 7624	}
 7625	res := resTmp.(*introspection.Schema)
 7626	fc.Result = res
 7627	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 7628}
 7629
 7630func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7631	defer func() {
 7632		if r := recover(); r != nil {
 7633			ec.Error(ctx, ec.Recover(ctx, r))
 7634			ret = graphql.Null
 7635		}
 7636	}()
 7637	fc := &graphql.FieldContext{
 7638		Object:   "Repository",
 7639		Field:    field,
 7640		Args:     nil,
 7641		IsMethod: true,
 7642	}
 7643
 7644	ctx = graphql.WithFieldContext(ctx, fc)
 7645	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7646		ctx = rctx // use context from middleware stack in children
 7647		return ec.resolvers.Repository().Name(rctx, obj)
 7648	})
 7649	if err != nil {
 7650		ec.Error(ctx, err)
 7651		return graphql.Null
 7652	}
 7653	if resTmp == nil {
 7654		return graphql.Null
 7655	}
 7656	res := resTmp.(*string)
 7657	fc.Result = res
 7658	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7659}
 7660
 7661func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7662	defer func() {
 7663		if r := recover(); r != nil {
 7664			ec.Error(ctx, ec.Recover(ctx, r))
 7665			ret = graphql.Null
 7666		}
 7667	}()
 7668	fc := &graphql.FieldContext{
 7669		Object:   "Repository",
 7670		Field:    field,
 7671		Args:     nil,
 7672		IsMethod: true,
 7673	}
 7674
 7675	ctx = graphql.WithFieldContext(ctx, fc)
 7676	rawArgs := field.ArgumentMap(ec.Variables)
 7677	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 7678	if err != nil {
 7679		ec.Error(ctx, err)
 7680		return graphql.Null
 7681	}
 7682	fc.Args = args
 7683	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7684		ctx = rctx // use context from middleware stack in children
 7685		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 7686	})
 7687	if err != nil {
 7688		ec.Error(ctx, err)
 7689		return graphql.Null
 7690	}
 7691	if resTmp == nil {
 7692		if !graphql.HasFieldError(ctx, fc) {
 7693			ec.Errorf(ctx, "must not be null")
 7694		}
 7695		return graphql.Null
 7696	}
 7697	res := resTmp.(*models.BugConnection)
 7698	fc.Result = res
 7699	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 7700}
 7701
 7702func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7703	defer func() {
 7704		if r := recover(); r != nil {
 7705			ec.Error(ctx, ec.Recover(ctx, r))
 7706			ret = graphql.Null
 7707		}
 7708	}()
 7709	fc := &graphql.FieldContext{
 7710		Object:   "Repository",
 7711		Field:    field,
 7712		Args:     nil,
 7713		IsMethod: true,
 7714	}
 7715
 7716	ctx = graphql.WithFieldContext(ctx, fc)
 7717	rawArgs := field.ArgumentMap(ec.Variables)
 7718	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 7719	if err != nil {
 7720		ec.Error(ctx, err)
 7721		return graphql.Null
 7722	}
 7723	fc.Args = args
 7724	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7725		ctx = rctx // use context from middleware stack in children
 7726		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 7727	})
 7728	if err != nil {
 7729		ec.Error(ctx, err)
 7730		return graphql.Null
 7731	}
 7732	if resTmp == nil {
 7733		return graphql.Null
 7734	}
 7735	res := resTmp.(models.BugWrapper)
 7736	fc.Result = res
 7737	return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7738}
 7739
 7740func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7741	defer func() {
 7742		if r := recover(); r != nil {
 7743			ec.Error(ctx, ec.Recover(ctx, r))
 7744			ret = graphql.Null
 7745		}
 7746	}()
 7747	fc := &graphql.FieldContext{
 7748		Object:   "Repository",
 7749		Field:    field,
 7750		Args:     nil,
 7751		IsMethod: true,
 7752	}
 7753
 7754	ctx = graphql.WithFieldContext(ctx, fc)
 7755	rawArgs := field.ArgumentMap(ec.Variables)
 7756	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 7757	if err != nil {
 7758		ec.Error(ctx, err)
 7759		return graphql.Null
 7760	}
 7761	fc.Args = args
 7762	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7763		ctx = rctx // use context from middleware stack in children
 7764		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7765	})
 7766	if err != nil {
 7767		ec.Error(ctx, err)
 7768		return graphql.Null
 7769	}
 7770	if resTmp == nil {
 7771		if !graphql.HasFieldError(ctx, fc) {
 7772			ec.Errorf(ctx, "must not be null")
 7773		}
 7774		return graphql.Null
 7775	}
 7776	res := resTmp.(*models.IdentityConnection)
 7777	fc.Result = res
 7778	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 7779}
 7780
 7781func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7782	defer func() {
 7783		if r := recover(); r != nil {
 7784			ec.Error(ctx, ec.Recover(ctx, r))
 7785			ret = graphql.Null
 7786		}
 7787	}()
 7788	fc := &graphql.FieldContext{
 7789		Object:   "Repository",
 7790		Field:    field,
 7791		Args:     nil,
 7792		IsMethod: true,
 7793	}
 7794
 7795	ctx = graphql.WithFieldContext(ctx, fc)
 7796	rawArgs := field.ArgumentMap(ec.Variables)
 7797	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 7798	if err != nil {
 7799		ec.Error(ctx, err)
 7800		return graphql.Null
 7801	}
 7802	fc.Args = args
 7803	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7804		ctx = rctx // use context from middleware stack in children
 7805		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 7806	})
 7807	if err != nil {
 7808		ec.Error(ctx, err)
 7809		return graphql.Null
 7810	}
 7811	if resTmp == nil {
 7812		return graphql.Null
 7813	}
 7814	res := resTmp.(models.IdentityWrapper)
 7815	fc.Result = res
 7816	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7817}
 7818
 7819func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7820	defer func() {
 7821		if r := recover(); r != nil {
 7822			ec.Error(ctx, ec.Recover(ctx, r))
 7823			ret = graphql.Null
 7824		}
 7825	}()
 7826	fc := &graphql.FieldContext{
 7827		Object:   "Repository",
 7828		Field:    field,
 7829		Args:     nil,
 7830		IsMethod: true,
 7831	}
 7832
 7833	ctx = graphql.WithFieldContext(ctx, fc)
 7834	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7835		ctx = rctx // use context from middleware stack in children
 7836		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 7837	})
 7838	if err != nil {
 7839		ec.Error(ctx, err)
 7840		return graphql.Null
 7841	}
 7842	if resTmp == nil {
 7843		return graphql.Null
 7844	}
 7845	res := resTmp.(models.IdentityWrapper)
 7846	fc.Result = res
 7847	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7848}
 7849
 7850func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7851	defer func() {
 7852		if r := recover(); r != nil {
 7853			ec.Error(ctx, ec.Recover(ctx, r))
 7854			ret = graphql.Null
 7855		}
 7856	}()
 7857	fc := &graphql.FieldContext{
 7858		Object:   "Repository",
 7859		Field:    field,
 7860		Args:     nil,
 7861		IsMethod: true,
 7862	}
 7863
 7864	ctx = graphql.WithFieldContext(ctx, fc)
 7865	rawArgs := field.ArgumentMap(ec.Variables)
 7866	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 7867	if err != nil {
 7868		ec.Error(ctx, err)
 7869		return graphql.Null
 7870	}
 7871	fc.Args = args
 7872	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7873		ctx = rctx // use context from middleware stack in children
 7874		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7875	})
 7876	if err != nil {
 7877		ec.Error(ctx, err)
 7878		return graphql.Null
 7879	}
 7880	if resTmp == nil {
 7881		if !graphql.HasFieldError(ctx, fc) {
 7882			ec.Errorf(ctx, "must not be null")
 7883		}
 7884		return graphql.Null
 7885	}
 7886	res := resTmp.(*models.LabelConnection)
 7887	fc.Result = res
 7888	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 7889}
 7890
 7891func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7892	defer func() {
 7893		if r := recover(); r != nil {
 7894			ec.Error(ctx, ec.Recover(ctx, r))
 7895			ret = graphql.Null
 7896		}
 7897	}()
 7898	fc := &graphql.FieldContext{
 7899		Object:   "SetStatusOperation",
 7900		Field:    field,
 7901		Args:     nil,
 7902		IsMethod: true,
 7903	}
 7904
 7905	ctx = graphql.WithFieldContext(ctx, fc)
 7906	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7907		ctx = rctx // use context from middleware stack in children
 7908		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 7909	})
 7910	if err != nil {
 7911		ec.Error(ctx, err)
 7912		return graphql.Null
 7913	}
 7914	if resTmp == nil {
 7915		if !graphql.HasFieldError(ctx, fc) {
 7916			ec.Errorf(ctx, "must not be null")
 7917		}
 7918		return graphql.Null
 7919	}
 7920	res := resTmp.(string)
 7921	fc.Result = res
 7922	return ec.marshalNString2string(ctx, field.Selections, res)
 7923}
 7924
 7925func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7926	defer func() {
 7927		if r := recover(); r != nil {
 7928			ec.Error(ctx, ec.Recover(ctx, r))
 7929			ret = graphql.Null
 7930		}
 7931	}()
 7932	fc := &graphql.FieldContext{
 7933		Object:   "SetStatusOperation",
 7934		Field:    field,
 7935		Args:     nil,
 7936		IsMethod: true,
 7937	}
 7938
 7939	ctx = graphql.WithFieldContext(ctx, fc)
 7940	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7941		ctx = rctx // use context from middleware stack in children
 7942		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
 7943	})
 7944	if err != nil {
 7945		ec.Error(ctx, err)
 7946		return graphql.Null
 7947	}
 7948	if resTmp == nil {
 7949		if !graphql.HasFieldError(ctx, fc) {
 7950			ec.Errorf(ctx, "must not be null")
 7951		}
 7952		return graphql.Null
 7953	}
 7954	res := resTmp.(models.IdentityWrapper)
 7955	fc.Result = res
 7956	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7957}
 7958
 7959func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7960	defer func() {
 7961		if r := recover(); r != nil {
 7962			ec.Error(ctx, ec.Recover(ctx, r))
 7963			ret = graphql.Null
 7964		}
 7965	}()
 7966	fc := &graphql.FieldContext{
 7967		Object:   "SetStatusOperation",
 7968		Field:    field,
 7969		Args:     nil,
 7970		IsMethod: true,
 7971	}
 7972
 7973	ctx = graphql.WithFieldContext(ctx, fc)
 7974	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7975		ctx = rctx // use context from middleware stack in children
 7976		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 7977	})
 7978	if err != nil {
 7979		ec.Error(ctx, err)
 7980		return graphql.Null
 7981	}
 7982	if resTmp == nil {
 7983		if !graphql.HasFieldError(ctx, fc) {
 7984			ec.Errorf(ctx, "must not be null")
 7985		}
 7986		return graphql.Null
 7987	}
 7988	res := resTmp.(*time.Time)
 7989	fc.Result = res
 7990	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7991}
 7992
 7993func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7994	defer func() {
 7995		if r := recover(); r != nil {
 7996			ec.Error(ctx, ec.Recover(ctx, r))
 7997			ret = graphql.Null
 7998		}
 7999	}()
 8000	fc := &graphql.FieldContext{
 8001		Object:   "SetStatusOperation",
 8002		Field:    field,
 8003		Args:     nil,
 8004		IsMethod: true,
 8005	}
 8006
 8007	ctx = graphql.WithFieldContext(ctx, fc)
 8008	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8009		ctx = rctx // use context from middleware stack in children
 8010		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8011	})
 8012	if err != nil {
 8013		ec.Error(ctx, err)
 8014		return graphql.Null
 8015	}
 8016	if resTmp == nil {
 8017		if !graphql.HasFieldError(ctx, fc) {
 8018			ec.Errorf(ctx, "must not be null")
 8019		}
 8020		return graphql.Null
 8021	}
 8022	res := resTmp.(models.Status)
 8023	fc.Result = res
 8024	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8025}
 8026
 8027func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8028	defer func() {
 8029		if r := recover(); r != nil {
 8030			ec.Error(ctx, ec.Recover(ctx, r))
 8031			ret = graphql.Null
 8032		}
 8033	}()
 8034	fc := &graphql.FieldContext{
 8035		Object:   "SetStatusTimelineItem",
 8036		Field:    field,
 8037		Args:     nil,
 8038		IsMethod: true,
 8039	}
 8040
 8041	ctx = graphql.WithFieldContext(ctx, fc)
 8042	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8043		ctx = rctx // use context from middleware stack in children
 8044		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8045	})
 8046	if err != nil {
 8047		ec.Error(ctx, err)
 8048		return graphql.Null
 8049	}
 8050	if resTmp == nil {
 8051		if !graphql.HasFieldError(ctx, fc) {
 8052			ec.Errorf(ctx, "must not be null")
 8053		}
 8054		return graphql.Null
 8055	}
 8056	res := resTmp.(string)
 8057	fc.Result = res
 8058	return ec.marshalNString2string(ctx, field.Selections, res)
 8059}
 8060
 8061func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8062	defer func() {
 8063		if r := recover(); r != nil {
 8064			ec.Error(ctx, ec.Recover(ctx, r))
 8065			ret = graphql.Null
 8066		}
 8067	}()
 8068	fc := &graphql.FieldContext{
 8069		Object:   "SetStatusTimelineItem",
 8070		Field:    field,
 8071		Args:     nil,
 8072		IsMethod: true,
 8073	}
 8074
 8075	ctx = graphql.WithFieldContext(ctx, fc)
 8076	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8077		ctx = rctx // use context from middleware stack in children
 8078		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
 8079	})
 8080	if err != nil {
 8081		ec.Error(ctx, err)
 8082		return graphql.Null
 8083	}
 8084	if resTmp == nil {
 8085		if !graphql.HasFieldError(ctx, fc) {
 8086			ec.Errorf(ctx, "must not be null")
 8087		}
 8088		return graphql.Null
 8089	}
 8090	res := resTmp.(models.IdentityWrapper)
 8091	fc.Result = res
 8092	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8093}
 8094
 8095func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8096	defer func() {
 8097		if r := recover(); r != nil {
 8098			ec.Error(ctx, ec.Recover(ctx, r))
 8099			ret = graphql.Null
 8100		}
 8101	}()
 8102	fc := &graphql.FieldContext{
 8103		Object:   "SetStatusTimelineItem",
 8104		Field:    field,
 8105		Args:     nil,
 8106		IsMethod: true,
 8107	}
 8108
 8109	ctx = graphql.WithFieldContext(ctx, fc)
 8110	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8111		ctx = rctx // use context from middleware stack in children
 8112		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8113	})
 8114	if err != nil {
 8115		ec.Error(ctx, err)
 8116		return graphql.Null
 8117	}
 8118	if resTmp == nil {
 8119		if !graphql.HasFieldError(ctx, fc) {
 8120			ec.Errorf(ctx, "must not be null")
 8121		}
 8122		return graphql.Null
 8123	}
 8124	res := resTmp.(*time.Time)
 8125	fc.Result = res
 8126	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8127}
 8128
 8129func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8130	defer func() {
 8131		if r := recover(); r != nil {
 8132			ec.Error(ctx, ec.Recover(ctx, r))
 8133			ret = graphql.Null
 8134		}
 8135	}()
 8136	fc := &graphql.FieldContext{
 8137		Object:   "SetStatusTimelineItem",
 8138		Field:    field,
 8139		Args:     nil,
 8140		IsMethod: true,
 8141	}
 8142
 8143	ctx = graphql.WithFieldContext(ctx, fc)
 8144	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8145		ctx = rctx // use context from middleware stack in children
 8146		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8147	})
 8148	if err != nil {
 8149		ec.Error(ctx, err)
 8150		return graphql.Null
 8151	}
 8152	if resTmp == nil {
 8153		if !graphql.HasFieldError(ctx, fc) {
 8154			ec.Errorf(ctx, "must not be null")
 8155		}
 8156		return graphql.Null
 8157	}
 8158	res := resTmp.(models.Status)
 8159	fc.Result = res
 8160	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8161}
 8162
 8163func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8164	defer func() {
 8165		if r := recover(); r != nil {
 8166			ec.Error(ctx, ec.Recover(ctx, r))
 8167			ret = graphql.Null
 8168		}
 8169	}()
 8170	fc := &graphql.FieldContext{
 8171		Object:   "SetTitleOperation",
 8172		Field:    field,
 8173		Args:     nil,
 8174		IsMethod: true,
 8175	}
 8176
 8177	ctx = graphql.WithFieldContext(ctx, fc)
 8178	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8179		ctx = rctx // use context from middleware stack in children
 8180		return ec.resolvers.SetTitleOperation().ID(rctx, obj)
 8181	})
 8182	if err != nil {
 8183		ec.Error(ctx, err)
 8184		return graphql.Null
 8185	}
 8186	if resTmp == nil {
 8187		if !graphql.HasFieldError(ctx, fc) {
 8188			ec.Errorf(ctx, "must not be null")
 8189		}
 8190		return graphql.Null
 8191	}
 8192	res := resTmp.(string)
 8193	fc.Result = res
 8194	return ec.marshalNString2string(ctx, field.Selections, res)
 8195}
 8196
 8197func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8198	defer func() {
 8199		if r := recover(); r != nil {
 8200			ec.Error(ctx, ec.Recover(ctx, r))
 8201			ret = graphql.Null
 8202		}
 8203	}()
 8204	fc := &graphql.FieldContext{
 8205		Object:   "SetTitleOperation",
 8206		Field:    field,
 8207		Args:     nil,
 8208		IsMethod: true,
 8209	}
 8210
 8211	ctx = graphql.WithFieldContext(ctx, fc)
 8212	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8213		ctx = rctx // use context from middleware stack in children
 8214		return ec.resolvers.SetTitleOperation().Author(rctx, obj)
 8215	})
 8216	if err != nil {
 8217		ec.Error(ctx, err)
 8218		return graphql.Null
 8219	}
 8220	if resTmp == nil {
 8221		if !graphql.HasFieldError(ctx, fc) {
 8222			ec.Errorf(ctx, "must not be null")
 8223		}
 8224		return graphql.Null
 8225	}
 8226	res := resTmp.(models.IdentityWrapper)
 8227	fc.Result = res
 8228	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8229}
 8230
 8231func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8232	defer func() {
 8233		if r := recover(); r != nil {
 8234			ec.Error(ctx, ec.Recover(ctx, r))
 8235			ret = graphql.Null
 8236		}
 8237	}()
 8238	fc := &graphql.FieldContext{
 8239		Object:   "SetTitleOperation",
 8240		Field:    field,
 8241		Args:     nil,
 8242		IsMethod: true,
 8243	}
 8244
 8245	ctx = graphql.WithFieldContext(ctx, fc)
 8246	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8247		ctx = rctx // use context from middleware stack in children
 8248		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8249	})
 8250	if err != nil {
 8251		ec.Error(ctx, err)
 8252		return graphql.Null
 8253	}
 8254	if resTmp == nil {
 8255		if !graphql.HasFieldError(ctx, fc) {
 8256			ec.Errorf(ctx, "must not be null")
 8257		}
 8258		return graphql.Null
 8259	}
 8260	res := resTmp.(*time.Time)
 8261	fc.Result = res
 8262	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8263}
 8264
 8265func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8266	defer func() {
 8267		if r := recover(); r != nil {
 8268			ec.Error(ctx, ec.Recover(ctx, r))
 8269			ret = graphql.Null
 8270		}
 8271	}()
 8272	fc := &graphql.FieldContext{
 8273		Object:   "SetTitleOperation",
 8274		Field:    field,
 8275		Args:     nil,
 8276		IsMethod: false,
 8277	}
 8278
 8279	ctx = graphql.WithFieldContext(ctx, fc)
 8280	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8281		ctx = rctx // use context from middleware stack in children
 8282		return obj.Title, nil
 8283	})
 8284	if err != nil {
 8285		ec.Error(ctx, err)
 8286		return graphql.Null
 8287	}
 8288	if resTmp == nil {
 8289		if !graphql.HasFieldError(ctx, fc) {
 8290			ec.Errorf(ctx, "must not be null")
 8291		}
 8292		return graphql.Null
 8293	}
 8294	res := resTmp.(string)
 8295	fc.Result = res
 8296	return ec.marshalNString2string(ctx, field.Selections, res)
 8297}
 8298
 8299func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8300	defer func() {
 8301		if r := recover(); r != nil {
 8302			ec.Error(ctx, ec.Recover(ctx, r))
 8303			ret = graphql.Null
 8304		}
 8305	}()
 8306	fc := &graphql.FieldContext{
 8307		Object:   "SetTitleOperation",
 8308		Field:    field,
 8309		Args:     nil,
 8310		IsMethod: false,
 8311	}
 8312
 8313	ctx = graphql.WithFieldContext(ctx, fc)
 8314	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8315		ctx = rctx // use context from middleware stack in children
 8316		return obj.Was, nil
 8317	})
 8318	if err != nil {
 8319		ec.Error(ctx, err)
 8320		return graphql.Null
 8321	}
 8322	if resTmp == nil {
 8323		if !graphql.HasFieldError(ctx, fc) {
 8324			ec.Errorf(ctx, "must not be null")
 8325		}
 8326		return graphql.Null
 8327	}
 8328	res := resTmp.(string)
 8329	fc.Result = res
 8330	return ec.marshalNString2string(ctx, field.Selections, res)
 8331}
 8332
 8333func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8334	defer func() {
 8335		if r := recover(); r != nil {
 8336			ec.Error(ctx, ec.Recover(ctx, r))
 8337			ret = graphql.Null
 8338		}
 8339	}()
 8340	fc := &graphql.FieldContext{
 8341		Object:   "SetTitlePayload",
 8342		Field:    field,
 8343		Args:     nil,
 8344		IsMethod: false,
 8345	}
 8346
 8347	ctx = graphql.WithFieldContext(ctx, fc)
 8348	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8349		ctx = rctx // use context from middleware stack in children
 8350		return obj.ClientMutationID, nil
 8351	})
 8352	if err != nil {
 8353		ec.Error(ctx, err)
 8354		return graphql.Null
 8355	}
 8356	if resTmp == nil {
 8357		return graphql.Null
 8358	}
 8359	res := resTmp.(*string)
 8360	fc.Result = res
 8361	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8362}
 8363
 8364func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8365	defer func() {
 8366		if r := recover(); r != nil {
 8367			ec.Error(ctx, ec.Recover(ctx, r))
 8368			ret = graphql.Null
 8369		}
 8370	}()
 8371	fc := &graphql.FieldContext{
 8372		Object:   "SetTitlePayload",
 8373		Field:    field,
 8374		Args:     nil,
 8375		IsMethod: false,
 8376	}
 8377
 8378	ctx = graphql.WithFieldContext(ctx, fc)
 8379	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8380		ctx = rctx // use context from middleware stack in children
 8381		return obj.Bug, nil
 8382	})
 8383	if err != nil {
 8384		ec.Error(ctx, err)
 8385		return graphql.Null
 8386	}
 8387	if resTmp == nil {
 8388		if !graphql.HasFieldError(ctx, fc) {
 8389			ec.Errorf(ctx, "must not be null")
 8390		}
 8391		return graphql.Null
 8392	}
 8393	res := resTmp.(models.BugWrapper)
 8394	fc.Result = res
 8395	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 8396}
 8397
 8398func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8399	defer func() {
 8400		if r := recover(); r != nil {
 8401			ec.Error(ctx, ec.Recover(ctx, r))
 8402			ret = graphql.Null
 8403		}
 8404	}()
 8405	fc := &graphql.FieldContext{
 8406		Object:   "SetTitlePayload",
 8407		Field:    field,
 8408		Args:     nil,
 8409		IsMethod: false,
 8410	}
 8411
 8412	ctx = graphql.WithFieldContext(ctx, fc)
 8413	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8414		ctx = rctx // use context from middleware stack in children
 8415		return obj.Operation, nil
 8416	})
 8417	if err != nil {
 8418		ec.Error(ctx, err)
 8419		return graphql.Null
 8420	}
 8421	if resTmp == nil {
 8422		if !graphql.HasFieldError(ctx, fc) {
 8423			ec.Errorf(ctx, "must not be null")
 8424		}
 8425		return graphql.Null
 8426	}
 8427	res := resTmp.(*bug.SetTitleOperation)
 8428	fc.Result = res
 8429	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8430}
 8431
 8432func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8433	defer func() {
 8434		if r := recover(); r != nil {
 8435			ec.Error(ctx, ec.Recover(ctx, r))
 8436			ret = graphql.Null
 8437		}
 8438	}()
 8439	fc := &graphql.FieldContext{
 8440		Object:   "SetTitleTimelineItem",
 8441		Field:    field,
 8442		Args:     nil,
 8443		IsMethod: true,
 8444	}
 8445
 8446	ctx = graphql.WithFieldContext(ctx, fc)
 8447	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8448		ctx = rctx // use context from middleware stack in children
 8449		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8450	})
 8451	if err != nil {
 8452		ec.Error(ctx, err)
 8453		return graphql.Null
 8454	}
 8455	if resTmp == nil {
 8456		if !graphql.HasFieldError(ctx, fc) {
 8457			ec.Errorf(ctx, "must not be null")
 8458		}
 8459		return graphql.Null
 8460	}
 8461	res := resTmp.(string)
 8462	fc.Result = res
 8463	return ec.marshalNString2string(ctx, field.Selections, res)
 8464}
 8465
 8466func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8467	defer func() {
 8468		if r := recover(); r != nil {
 8469			ec.Error(ctx, ec.Recover(ctx, r))
 8470			ret = graphql.Null
 8471		}
 8472	}()
 8473	fc := &graphql.FieldContext{
 8474		Object:   "SetTitleTimelineItem",
 8475		Field:    field,
 8476		Args:     nil,
 8477		IsMethod: true,
 8478	}
 8479
 8480	ctx = graphql.WithFieldContext(ctx, fc)
 8481	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8482		ctx = rctx // use context from middleware stack in children
 8483		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
 8484	})
 8485	if err != nil {
 8486		ec.Error(ctx, err)
 8487		return graphql.Null
 8488	}
 8489	if resTmp == nil {
 8490		if !graphql.HasFieldError(ctx, fc) {
 8491			ec.Errorf(ctx, "must not be null")
 8492		}
 8493		return graphql.Null
 8494	}
 8495	res := resTmp.(models.IdentityWrapper)
 8496	fc.Result = res
 8497	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8498}
 8499
 8500func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8501	defer func() {
 8502		if r := recover(); r != nil {
 8503			ec.Error(ctx, ec.Recover(ctx, r))
 8504			ret = graphql.Null
 8505		}
 8506	}()
 8507	fc := &graphql.FieldContext{
 8508		Object:   "SetTitleTimelineItem",
 8509		Field:    field,
 8510		Args:     nil,
 8511		IsMethod: true,
 8512	}
 8513
 8514	ctx = graphql.WithFieldContext(ctx, fc)
 8515	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8516		ctx = rctx // use context from middleware stack in children
 8517		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8518	})
 8519	if err != nil {
 8520		ec.Error(ctx, err)
 8521		return graphql.Null
 8522	}
 8523	if resTmp == nil {
 8524		if !graphql.HasFieldError(ctx, fc) {
 8525			ec.Errorf(ctx, "must not be null")
 8526		}
 8527		return graphql.Null
 8528	}
 8529	res := resTmp.(*time.Time)
 8530	fc.Result = res
 8531	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8532}
 8533
 8534func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8535	defer func() {
 8536		if r := recover(); r != nil {
 8537			ec.Error(ctx, ec.Recover(ctx, r))
 8538			ret = graphql.Null
 8539		}
 8540	}()
 8541	fc := &graphql.FieldContext{
 8542		Object:   "SetTitleTimelineItem",
 8543		Field:    field,
 8544		Args:     nil,
 8545		IsMethod: false,
 8546	}
 8547
 8548	ctx = graphql.WithFieldContext(ctx, fc)
 8549	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8550		ctx = rctx // use context from middleware stack in children
 8551		return obj.Title, nil
 8552	})
 8553	if err != nil {
 8554		ec.Error(ctx, err)
 8555		return graphql.Null
 8556	}
 8557	if resTmp == nil {
 8558		if !graphql.HasFieldError(ctx, fc) {
 8559			ec.Errorf(ctx, "must not be null")
 8560		}
 8561		return graphql.Null
 8562	}
 8563	res := resTmp.(string)
 8564	fc.Result = res
 8565	return ec.marshalNString2string(ctx, field.Selections, res)
 8566}
 8567
 8568func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8569	defer func() {
 8570		if r := recover(); r != nil {
 8571			ec.Error(ctx, ec.Recover(ctx, r))
 8572			ret = graphql.Null
 8573		}
 8574	}()
 8575	fc := &graphql.FieldContext{
 8576		Object:   "SetTitleTimelineItem",
 8577		Field:    field,
 8578		Args:     nil,
 8579		IsMethod: false,
 8580	}
 8581
 8582	ctx = graphql.WithFieldContext(ctx, fc)
 8583	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8584		ctx = rctx // use context from middleware stack in children
 8585		return obj.Was, nil
 8586	})
 8587	if err != nil {
 8588		ec.Error(ctx, err)
 8589		return graphql.Null
 8590	}
 8591	if resTmp == nil {
 8592		if !graphql.HasFieldError(ctx, fc) {
 8593			ec.Errorf(ctx, "must not be null")
 8594		}
 8595		return graphql.Null
 8596	}
 8597	res := resTmp.(string)
 8598	fc.Result = res
 8599	return ec.marshalNString2string(ctx, field.Selections, res)
 8600}
 8601
 8602func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8603	defer func() {
 8604		if r := recover(); r != nil {
 8605			ec.Error(ctx, ec.Recover(ctx, r))
 8606			ret = graphql.Null
 8607		}
 8608	}()
 8609	fc := &graphql.FieldContext{
 8610		Object:   "TimelineItemConnection",
 8611		Field:    field,
 8612		Args:     nil,
 8613		IsMethod: false,
 8614	}
 8615
 8616	ctx = graphql.WithFieldContext(ctx, fc)
 8617	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8618		ctx = rctx // use context from middleware stack in children
 8619		return obj.Edges, nil
 8620	})
 8621	if err != nil {
 8622		ec.Error(ctx, err)
 8623		return graphql.Null
 8624	}
 8625	if resTmp == nil {
 8626		if !graphql.HasFieldError(ctx, fc) {
 8627			ec.Errorf(ctx, "must not be null")
 8628		}
 8629		return graphql.Null
 8630	}
 8631	res := resTmp.([]*models.TimelineItemEdge)
 8632	fc.Result = res
 8633	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 8634}
 8635
 8636func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8637	defer func() {
 8638		if r := recover(); r != nil {
 8639			ec.Error(ctx, ec.Recover(ctx, r))
 8640			ret = graphql.Null
 8641		}
 8642	}()
 8643	fc := &graphql.FieldContext{
 8644		Object:   "TimelineItemConnection",
 8645		Field:    field,
 8646		Args:     nil,
 8647		IsMethod: false,
 8648	}
 8649
 8650	ctx = graphql.WithFieldContext(ctx, fc)
 8651	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8652		ctx = rctx // use context from middleware stack in children
 8653		return obj.Nodes, nil
 8654	})
 8655	if err != nil {
 8656		ec.Error(ctx, err)
 8657		return graphql.Null
 8658	}
 8659	if resTmp == nil {
 8660		if !graphql.HasFieldError(ctx, fc) {
 8661			ec.Errorf(ctx, "must not be null")
 8662		}
 8663		return graphql.Null
 8664	}
 8665	res := resTmp.([]bug.TimelineItem)
 8666	fc.Result = res
 8667	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 8668}
 8669
 8670func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8671	defer func() {
 8672		if r := recover(); r != nil {
 8673			ec.Error(ctx, ec.Recover(ctx, r))
 8674			ret = graphql.Null
 8675		}
 8676	}()
 8677	fc := &graphql.FieldContext{
 8678		Object:   "TimelineItemConnection",
 8679		Field:    field,
 8680		Args:     nil,
 8681		IsMethod: false,
 8682	}
 8683
 8684	ctx = graphql.WithFieldContext(ctx, fc)
 8685	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8686		ctx = rctx // use context from middleware stack in children
 8687		return obj.PageInfo, nil
 8688	})
 8689	if err != nil {
 8690		ec.Error(ctx, err)
 8691		return graphql.Null
 8692	}
 8693	if resTmp == nil {
 8694		if !graphql.HasFieldError(ctx, fc) {
 8695			ec.Errorf(ctx, "must not be null")
 8696		}
 8697		return graphql.Null
 8698	}
 8699	res := resTmp.(*models.PageInfo)
 8700	fc.Result = res
 8701	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 8702}
 8703
 8704func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8705	defer func() {
 8706		if r := recover(); r != nil {
 8707			ec.Error(ctx, ec.Recover(ctx, r))
 8708			ret = graphql.Null
 8709		}
 8710	}()
 8711	fc := &graphql.FieldContext{
 8712		Object:   "TimelineItemConnection",
 8713		Field:    field,
 8714		Args:     nil,
 8715		IsMethod: false,
 8716	}
 8717
 8718	ctx = graphql.WithFieldContext(ctx, fc)
 8719	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8720		ctx = rctx // use context from middleware stack in children
 8721		return obj.TotalCount, nil
 8722	})
 8723	if err != nil {
 8724		ec.Error(ctx, err)
 8725		return graphql.Null
 8726	}
 8727	if resTmp == nil {
 8728		if !graphql.HasFieldError(ctx, fc) {
 8729			ec.Errorf(ctx, "must not be null")
 8730		}
 8731		return graphql.Null
 8732	}
 8733	res := resTmp.(int)
 8734	fc.Result = res
 8735	return ec.marshalNInt2int(ctx, field.Selections, res)
 8736}
 8737
 8738func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8739	defer func() {
 8740		if r := recover(); r != nil {
 8741			ec.Error(ctx, ec.Recover(ctx, r))
 8742			ret = graphql.Null
 8743		}
 8744	}()
 8745	fc := &graphql.FieldContext{
 8746		Object:   "TimelineItemEdge",
 8747		Field:    field,
 8748		Args:     nil,
 8749		IsMethod: false,
 8750	}
 8751
 8752	ctx = graphql.WithFieldContext(ctx, fc)
 8753	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8754		ctx = rctx // use context from middleware stack in children
 8755		return obj.Cursor, nil
 8756	})
 8757	if err != nil {
 8758		ec.Error(ctx, err)
 8759		return graphql.Null
 8760	}
 8761	if resTmp == nil {
 8762		if !graphql.HasFieldError(ctx, fc) {
 8763			ec.Errorf(ctx, "must not be null")
 8764		}
 8765		return graphql.Null
 8766	}
 8767	res := resTmp.(string)
 8768	fc.Result = res
 8769	return ec.marshalNString2string(ctx, field.Selections, res)
 8770}
 8771
 8772func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8773	defer func() {
 8774		if r := recover(); r != nil {
 8775			ec.Error(ctx, ec.Recover(ctx, r))
 8776			ret = graphql.Null
 8777		}
 8778	}()
 8779	fc := &graphql.FieldContext{
 8780		Object:   "TimelineItemEdge",
 8781		Field:    field,
 8782		Args:     nil,
 8783		IsMethod: false,
 8784	}
 8785
 8786	ctx = graphql.WithFieldContext(ctx, fc)
 8787	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8788		ctx = rctx // use context from middleware stack in children
 8789		return obj.Node, nil
 8790	})
 8791	if err != nil {
 8792		ec.Error(ctx, err)
 8793		return graphql.Null
 8794	}
 8795	if resTmp == nil {
 8796		if !graphql.HasFieldError(ctx, fc) {
 8797			ec.Errorf(ctx, "must not be null")
 8798		}
 8799		return graphql.Null
 8800	}
 8801	res := resTmp.(bug.TimelineItem)
 8802	fc.Result = res
 8803	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 8804}
 8805
 8806func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8807	defer func() {
 8808		if r := recover(); r != nil {
 8809			ec.Error(ctx, ec.Recover(ctx, r))
 8810			ret = graphql.Null
 8811		}
 8812	}()
 8813	fc := &graphql.FieldContext{
 8814		Object:   "__Directive",
 8815		Field:    field,
 8816		Args:     nil,
 8817		IsMethod: false,
 8818	}
 8819
 8820	ctx = graphql.WithFieldContext(ctx, fc)
 8821	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8822		ctx = rctx // use context from middleware stack in children
 8823		return obj.Name, nil
 8824	})
 8825	if err != nil {
 8826		ec.Error(ctx, err)
 8827		return graphql.Null
 8828	}
 8829	if resTmp == nil {
 8830		if !graphql.HasFieldError(ctx, fc) {
 8831			ec.Errorf(ctx, "must not be null")
 8832		}
 8833		return graphql.Null
 8834	}
 8835	res := resTmp.(string)
 8836	fc.Result = res
 8837	return ec.marshalNString2string(ctx, field.Selections, res)
 8838}
 8839
 8840func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8841	defer func() {
 8842		if r := recover(); r != nil {
 8843			ec.Error(ctx, ec.Recover(ctx, r))
 8844			ret = graphql.Null
 8845		}
 8846	}()
 8847	fc := &graphql.FieldContext{
 8848		Object:   "__Directive",
 8849		Field:    field,
 8850		Args:     nil,
 8851		IsMethod: false,
 8852	}
 8853
 8854	ctx = graphql.WithFieldContext(ctx, fc)
 8855	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8856		ctx = rctx // use context from middleware stack in children
 8857		return obj.Description, nil
 8858	})
 8859	if err != nil {
 8860		ec.Error(ctx, err)
 8861		return graphql.Null
 8862	}
 8863	if resTmp == nil {
 8864		return graphql.Null
 8865	}
 8866	res := resTmp.(string)
 8867	fc.Result = res
 8868	return ec.marshalOString2string(ctx, field.Selections, res)
 8869}
 8870
 8871func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8872	defer func() {
 8873		if r := recover(); r != nil {
 8874			ec.Error(ctx, ec.Recover(ctx, r))
 8875			ret = graphql.Null
 8876		}
 8877	}()
 8878	fc := &graphql.FieldContext{
 8879		Object:   "__Directive",
 8880		Field:    field,
 8881		Args:     nil,
 8882		IsMethod: false,
 8883	}
 8884
 8885	ctx = graphql.WithFieldContext(ctx, fc)
 8886	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8887		ctx = rctx // use context from middleware stack in children
 8888		return obj.Locations, nil
 8889	})
 8890	if err != nil {
 8891		ec.Error(ctx, err)
 8892		return graphql.Null
 8893	}
 8894	if resTmp == nil {
 8895		if !graphql.HasFieldError(ctx, fc) {
 8896			ec.Errorf(ctx, "must not be null")
 8897		}
 8898		return graphql.Null
 8899	}
 8900	res := resTmp.([]string)
 8901	fc.Result = res
 8902	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 8903}
 8904
 8905func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8906	defer func() {
 8907		if r := recover(); r != nil {
 8908			ec.Error(ctx, ec.Recover(ctx, r))
 8909			ret = graphql.Null
 8910		}
 8911	}()
 8912	fc := &graphql.FieldContext{
 8913		Object:   "__Directive",
 8914		Field:    field,
 8915		Args:     nil,
 8916		IsMethod: false,
 8917	}
 8918
 8919	ctx = graphql.WithFieldContext(ctx, fc)
 8920	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8921		ctx = rctx // use context from middleware stack in children
 8922		return obj.Args, nil
 8923	})
 8924	if err != nil {
 8925		ec.Error(ctx, err)
 8926		return graphql.Null
 8927	}
 8928	if resTmp == nil {
 8929		if !graphql.HasFieldError(ctx, fc) {
 8930			ec.Errorf(ctx, "must not be null")
 8931		}
 8932		return graphql.Null
 8933	}
 8934	res := resTmp.([]introspection.InputValue)
 8935	fc.Result = res
 8936	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 8937}
 8938
 8939func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8940	defer func() {
 8941		if r := recover(); r != nil {
 8942			ec.Error(ctx, ec.Recover(ctx, r))
 8943			ret = graphql.Null
 8944		}
 8945	}()
 8946	fc := &graphql.FieldContext{
 8947		Object:   "__EnumValue",
 8948		Field:    field,
 8949		Args:     nil,
 8950		IsMethod: false,
 8951	}
 8952
 8953	ctx = graphql.WithFieldContext(ctx, fc)
 8954	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8955		ctx = rctx // use context from middleware stack in children
 8956		return obj.Name, nil
 8957	})
 8958	if err != nil {
 8959		ec.Error(ctx, err)
 8960		return graphql.Null
 8961	}
 8962	if resTmp == nil {
 8963		if !graphql.HasFieldError(ctx, fc) {
 8964			ec.Errorf(ctx, "must not be null")
 8965		}
 8966		return graphql.Null
 8967	}
 8968	res := resTmp.(string)
 8969	fc.Result = res
 8970	return ec.marshalNString2string(ctx, field.Selections, res)
 8971}
 8972
 8973func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8974	defer func() {
 8975		if r := recover(); r != nil {
 8976			ec.Error(ctx, ec.Recover(ctx, r))
 8977			ret = graphql.Null
 8978		}
 8979	}()
 8980	fc := &graphql.FieldContext{
 8981		Object:   "__EnumValue",
 8982		Field:    field,
 8983		Args:     nil,
 8984		IsMethod: false,
 8985	}
 8986
 8987	ctx = graphql.WithFieldContext(ctx, fc)
 8988	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8989		ctx = rctx // use context from middleware stack in children
 8990		return obj.Description, nil
 8991	})
 8992	if err != nil {
 8993		ec.Error(ctx, err)
 8994		return graphql.Null
 8995	}
 8996	if resTmp == nil {
 8997		return graphql.Null
 8998	}
 8999	res := resTmp.(string)
 9000	fc.Result = res
 9001	return ec.marshalOString2string(ctx, field.Selections, res)
 9002}
 9003
 9004func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9005	defer func() {
 9006		if r := recover(); r != nil {
 9007			ec.Error(ctx, ec.Recover(ctx, r))
 9008			ret = graphql.Null
 9009		}
 9010	}()
 9011	fc := &graphql.FieldContext{
 9012		Object:   "__EnumValue",
 9013		Field:    field,
 9014		Args:     nil,
 9015		IsMethod: true,
 9016	}
 9017
 9018	ctx = graphql.WithFieldContext(ctx, fc)
 9019	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9020		ctx = rctx // use context from middleware stack in children
 9021		return obj.IsDeprecated(), nil
 9022	})
 9023	if err != nil {
 9024		ec.Error(ctx, err)
 9025		return graphql.Null
 9026	}
 9027	if resTmp == nil {
 9028		if !graphql.HasFieldError(ctx, fc) {
 9029			ec.Errorf(ctx, "must not be null")
 9030		}
 9031		return graphql.Null
 9032	}
 9033	res := resTmp.(bool)
 9034	fc.Result = res
 9035	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9036}
 9037
 9038func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9039	defer func() {
 9040		if r := recover(); r != nil {
 9041			ec.Error(ctx, ec.Recover(ctx, r))
 9042			ret = graphql.Null
 9043		}
 9044	}()
 9045	fc := &graphql.FieldContext{
 9046		Object:   "__EnumValue",
 9047		Field:    field,
 9048		Args:     nil,
 9049		IsMethod: true,
 9050	}
 9051
 9052	ctx = graphql.WithFieldContext(ctx, fc)
 9053	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9054		ctx = rctx // use context from middleware stack in children
 9055		return obj.DeprecationReason(), nil
 9056	})
 9057	if err != nil {
 9058		ec.Error(ctx, err)
 9059		return graphql.Null
 9060	}
 9061	if resTmp == nil {
 9062		return graphql.Null
 9063	}
 9064	res := resTmp.(*string)
 9065	fc.Result = res
 9066	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9067}
 9068
 9069func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9070	defer func() {
 9071		if r := recover(); r != nil {
 9072			ec.Error(ctx, ec.Recover(ctx, r))
 9073			ret = graphql.Null
 9074		}
 9075	}()
 9076	fc := &graphql.FieldContext{
 9077		Object:   "__Field",
 9078		Field:    field,
 9079		Args:     nil,
 9080		IsMethod: false,
 9081	}
 9082
 9083	ctx = graphql.WithFieldContext(ctx, fc)
 9084	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9085		ctx = rctx // use context from middleware stack in children
 9086		return obj.Name, nil
 9087	})
 9088	if err != nil {
 9089		ec.Error(ctx, err)
 9090		return graphql.Null
 9091	}
 9092	if resTmp == nil {
 9093		if !graphql.HasFieldError(ctx, fc) {
 9094			ec.Errorf(ctx, "must not be null")
 9095		}
 9096		return graphql.Null
 9097	}
 9098	res := resTmp.(string)
 9099	fc.Result = res
 9100	return ec.marshalNString2string(ctx, field.Selections, res)
 9101}
 9102
 9103func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9104	defer func() {
 9105		if r := recover(); r != nil {
 9106			ec.Error(ctx, ec.Recover(ctx, r))
 9107			ret = graphql.Null
 9108		}
 9109	}()
 9110	fc := &graphql.FieldContext{
 9111		Object:   "__Field",
 9112		Field:    field,
 9113		Args:     nil,
 9114		IsMethod: false,
 9115	}
 9116
 9117	ctx = graphql.WithFieldContext(ctx, fc)
 9118	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9119		ctx = rctx // use context from middleware stack in children
 9120		return obj.Description, nil
 9121	})
 9122	if err != nil {
 9123		ec.Error(ctx, err)
 9124		return graphql.Null
 9125	}
 9126	if resTmp == nil {
 9127		return graphql.Null
 9128	}
 9129	res := resTmp.(string)
 9130	fc.Result = res
 9131	return ec.marshalOString2string(ctx, field.Selections, res)
 9132}
 9133
 9134func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9135	defer func() {
 9136		if r := recover(); r != nil {
 9137			ec.Error(ctx, ec.Recover(ctx, r))
 9138			ret = graphql.Null
 9139		}
 9140	}()
 9141	fc := &graphql.FieldContext{
 9142		Object:   "__Field",
 9143		Field:    field,
 9144		Args:     nil,
 9145		IsMethod: false,
 9146	}
 9147
 9148	ctx = graphql.WithFieldContext(ctx, fc)
 9149	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9150		ctx = rctx // use context from middleware stack in children
 9151		return obj.Args, nil
 9152	})
 9153	if err != nil {
 9154		ec.Error(ctx, err)
 9155		return graphql.Null
 9156	}
 9157	if resTmp == nil {
 9158		if !graphql.HasFieldError(ctx, fc) {
 9159			ec.Errorf(ctx, "must not be null")
 9160		}
 9161		return graphql.Null
 9162	}
 9163	res := resTmp.([]introspection.InputValue)
 9164	fc.Result = res
 9165	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9166}
 9167
 9168func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9169	defer func() {
 9170		if r := recover(); r != nil {
 9171			ec.Error(ctx, ec.Recover(ctx, r))
 9172			ret = graphql.Null
 9173		}
 9174	}()
 9175	fc := &graphql.FieldContext{
 9176		Object:   "__Field",
 9177		Field:    field,
 9178		Args:     nil,
 9179		IsMethod: false,
 9180	}
 9181
 9182	ctx = graphql.WithFieldContext(ctx, fc)
 9183	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9184		ctx = rctx // use context from middleware stack in children
 9185		return obj.Type, nil
 9186	})
 9187	if err != nil {
 9188		ec.Error(ctx, err)
 9189		return graphql.Null
 9190	}
 9191	if resTmp == nil {
 9192		if !graphql.HasFieldError(ctx, fc) {
 9193			ec.Errorf(ctx, "must not be null")
 9194		}
 9195		return graphql.Null
 9196	}
 9197	res := resTmp.(*introspection.Type)
 9198	fc.Result = res
 9199	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9200}
 9201
 9202func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9203	defer func() {
 9204		if r := recover(); r != nil {
 9205			ec.Error(ctx, ec.Recover(ctx, r))
 9206			ret = graphql.Null
 9207		}
 9208	}()
 9209	fc := &graphql.FieldContext{
 9210		Object:   "__Field",
 9211		Field:    field,
 9212		Args:     nil,
 9213		IsMethod: true,
 9214	}
 9215
 9216	ctx = graphql.WithFieldContext(ctx, fc)
 9217	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9218		ctx = rctx // use context from middleware stack in children
 9219		return obj.IsDeprecated(), nil
 9220	})
 9221	if err != nil {
 9222		ec.Error(ctx, err)
 9223		return graphql.Null
 9224	}
 9225	if resTmp == nil {
 9226		if !graphql.HasFieldError(ctx, fc) {
 9227			ec.Errorf(ctx, "must not be null")
 9228		}
 9229		return graphql.Null
 9230	}
 9231	res := resTmp.(bool)
 9232	fc.Result = res
 9233	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9234}
 9235
 9236func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9237	defer func() {
 9238		if r := recover(); r != nil {
 9239			ec.Error(ctx, ec.Recover(ctx, r))
 9240			ret = graphql.Null
 9241		}
 9242	}()
 9243	fc := &graphql.FieldContext{
 9244		Object:   "__Field",
 9245		Field:    field,
 9246		Args:     nil,
 9247		IsMethod: true,
 9248	}
 9249
 9250	ctx = graphql.WithFieldContext(ctx, fc)
 9251	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9252		ctx = rctx // use context from middleware stack in children
 9253		return obj.DeprecationReason(), nil
 9254	})
 9255	if err != nil {
 9256		ec.Error(ctx, err)
 9257		return graphql.Null
 9258	}
 9259	if resTmp == nil {
 9260		return graphql.Null
 9261	}
 9262	res := resTmp.(*string)
 9263	fc.Result = res
 9264	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9265}
 9266
 9267func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9268	defer func() {
 9269		if r := recover(); r != nil {
 9270			ec.Error(ctx, ec.Recover(ctx, r))
 9271			ret = graphql.Null
 9272		}
 9273	}()
 9274	fc := &graphql.FieldContext{
 9275		Object:   "__InputValue",
 9276		Field:    field,
 9277		Args:     nil,
 9278		IsMethod: false,
 9279	}
 9280
 9281	ctx = graphql.WithFieldContext(ctx, fc)
 9282	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9283		ctx = rctx // use context from middleware stack in children
 9284		return obj.Name, nil
 9285	})
 9286	if err != nil {
 9287		ec.Error(ctx, err)
 9288		return graphql.Null
 9289	}
 9290	if resTmp == nil {
 9291		if !graphql.HasFieldError(ctx, fc) {
 9292			ec.Errorf(ctx, "must not be null")
 9293		}
 9294		return graphql.Null
 9295	}
 9296	res := resTmp.(string)
 9297	fc.Result = res
 9298	return ec.marshalNString2string(ctx, field.Selections, res)
 9299}
 9300
 9301func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9302	defer func() {
 9303		if r := recover(); r != nil {
 9304			ec.Error(ctx, ec.Recover(ctx, r))
 9305			ret = graphql.Null
 9306		}
 9307	}()
 9308	fc := &graphql.FieldContext{
 9309		Object:   "__InputValue",
 9310		Field:    field,
 9311		Args:     nil,
 9312		IsMethod: false,
 9313	}
 9314
 9315	ctx = graphql.WithFieldContext(ctx, fc)
 9316	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9317		ctx = rctx // use context from middleware stack in children
 9318		return obj.Description, nil
 9319	})
 9320	if err != nil {
 9321		ec.Error(ctx, err)
 9322		return graphql.Null
 9323	}
 9324	if resTmp == nil {
 9325		return graphql.Null
 9326	}
 9327	res := resTmp.(string)
 9328	fc.Result = res
 9329	return ec.marshalOString2string(ctx, field.Selections, res)
 9330}
 9331
 9332func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9333	defer func() {
 9334		if r := recover(); r != nil {
 9335			ec.Error(ctx, ec.Recover(ctx, r))
 9336			ret = graphql.Null
 9337		}
 9338	}()
 9339	fc := &graphql.FieldContext{
 9340		Object:   "__InputValue",
 9341		Field:    field,
 9342		Args:     nil,
 9343		IsMethod: false,
 9344	}
 9345
 9346	ctx = graphql.WithFieldContext(ctx, fc)
 9347	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9348		ctx = rctx // use context from middleware stack in children
 9349		return obj.Type, nil
 9350	})
 9351	if err != nil {
 9352		ec.Error(ctx, err)
 9353		return graphql.Null
 9354	}
 9355	if resTmp == nil {
 9356		if !graphql.HasFieldError(ctx, fc) {
 9357			ec.Errorf(ctx, "must not be null")
 9358		}
 9359		return graphql.Null
 9360	}
 9361	res := resTmp.(*introspection.Type)
 9362	fc.Result = res
 9363	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9364}
 9365
 9366func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9367	defer func() {
 9368		if r := recover(); r != nil {
 9369			ec.Error(ctx, ec.Recover(ctx, r))
 9370			ret = graphql.Null
 9371		}
 9372	}()
 9373	fc := &graphql.FieldContext{
 9374		Object:   "__InputValue",
 9375		Field:    field,
 9376		Args:     nil,
 9377		IsMethod: false,
 9378	}
 9379
 9380	ctx = graphql.WithFieldContext(ctx, fc)
 9381	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9382		ctx = rctx // use context from middleware stack in children
 9383		return obj.DefaultValue, nil
 9384	})
 9385	if err != nil {
 9386		ec.Error(ctx, err)
 9387		return graphql.Null
 9388	}
 9389	if resTmp == nil {
 9390		return graphql.Null
 9391	}
 9392	res := resTmp.(*string)
 9393	fc.Result = res
 9394	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9395}
 9396
 9397func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9398	defer func() {
 9399		if r := recover(); r != nil {
 9400			ec.Error(ctx, ec.Recover(ctx, r))
 9401			ret = graphql.Null
 9402		}
 9403	}()
 9404	fc := &graphql.FieldContext{
 9405		Object:   "__Schema",
 9406		Field:    field,
 9407		Args:     nil,
 9408		IsMethod: true,
 9409	}
 9410
 9411	ctx = graphql.WithFieldContext(ctx, fc)
 9412	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9413		ctx = rctx // use context from middleware stack in children
 9414		return obj.Types(), nil
 9415	})
 9416	if err != nil {
 9417		ec.Error(ctx, err)
 9418		return graphql.Null
 9419	}
 9420	if resTmp == nil {
 9421		if !graphql.HasFieldError(ctx, fc) {
 9422			ec.Errorf(ctx, "must not be null")
 9423		}
 9424		return graphql.Null
 9425	}
 9426	res := resTmp.([]introspection.Type)
 9427	fc.Result = res
 9428	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9429}
 9430
 9431func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9432	defer func() {
 9433		if r := recover(); r != nil {
 9434			ec.Error(ctx, ec.Recover(ctx, r))
 9435			ret = graphql.Null
 9436		}
 9437	}()
 9438	fc := &graphql.FieldContext{
 9439		Object:   "__Schema",
 9440		Field:    field,
 9441		Args:     nil,
 9442		IsMethod: true,
 9443	}
 9444
 9445	ctx = graphql.WithFieldContext(ctx, fc)
 9446	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9447		ctx = rctx // use context from middleware stack in children
 9448		return obj.QueryType(), nil
 9449	})
 9450	if err != nil {
 9451		ec.Error(ctx, err)
 9452		return graphql.Null
 9453	}
 9454	if resTmp == nil {
 9455		if !graphql.HasFieldError(ctx, fc) {
 9456			ec.Errorf(ctx, "must not be null")
 9457		}
 9458		return graphql.Null
 9459	}
 9460	res := resTmp.(*introspection.Type)
 9461	fc.Result = res
 9462	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9463}
 9464
 9465func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9466	defer func() {
 9467		if r := recover(); r != nil {
 9468			ec.Error(ctx, ec.Recover(ctx, r))
 9469			ret = graphql.Null
 9470		}
 9471	}()
 9472	fc := &graphql.FieldContext{
 9473		Object:   "__Schema",
 9474		Field:    field,
 9475		Args:     nil,
 9476		IsMethod: true,
 9477	}
 9478
 9479	ctx = graphql.WithFieldContext(ctx, fc)
 9480	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9481		ctx = rctx // use context from middleware stack in children
 9482		return obj.MutationType(), nil
 9483	})
 9484	if err != nil {
 9485		ec.Error(ctx, err)
 9486		return graphql.Null
 9487	}
 9488	if resTmp == nil {
 9489		return graphql.Null
 9490	}
 9491	res := resTmp.(*introspection.Type)
 9492	fc.Result = res
 9493	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9494}
 9495
 9496func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9497	defer func() {
 9498		if r := recover(); r != nil {
 9499			ec.Error(ctx, ec.Recover(ctx, r))
 9500			ret = graphql.Null
 9501		}
 9502	}()
 9503	fc := &graphql.FieldContext{
 9504		Object:   "__Schema",
 9505		Field:    field,
 9506		Args:     nil,
 9507		IsMethod: true,
 9508	}
 9509
 9510	ctx = graphql.WithFieldContext(ctx, fc)
 9511	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9512		ctx = rctx // use context from middleware stack in children
 9513		return obj.SubscriptionType(), nil
 9514	})
 9515	if err != nil {
 9516		ec.Error(ctx, err)
 9517		return graphql.Null
 9518	}
 9519	if resTmp == nil {
 9520		return graphql.Null
 9521	}
 9522	res := resTmp.(*introspection.Type)
 9523	fc.Result = res
 9524	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9525}
 9526
 9527func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9528	defer func() {
 9529		if r := recover(); r != nil {
 9530			ec.Error(ctx, ec.Recover(ctx, r))
 9531			ret = graphql.Null
 9532		}
 9533	}()
 9534	fc := &graphql.FieldContext{
 9535		Object:   "__Schema",
 9536		Field:    field,
 9537		Args:     nil,
 9538		IsMethod: true,
 9539	}
 9540
 9541	ctx = graphql.WithFieldContext(ctx, fc)
 9542	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9543		ctx = rctx // use context from middleware stack in children
 9544		return obj.Directives(), nil
 9545	})
 9546	if err != nil {
 9547		ec.Error(ctx, err)
 9548		return graphql.Null
 9549	}
 9550	if resTmp == nil {
 9551		if !graphql.HasFieldError(ctx, fc) {
 9552			ec.Errorf(ctx, "must not be null")
 9553		}
 9554		return graphql.Null
 9555	}
 9556	res := resTmp.([]introspection.Directive)
 9557	fc.Result = res
 9558	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
 9559}
 9560
 9561func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9562	defer func() {
 9563		if r := recover(); r != nil {
 9564			ec.Error(ctx, ec.Recover(ctx, r))
 9565			ret = graphql.Null
 9566		}
 9567	}()
 9568	fc := &graphql.FieldContext{
 9569		Object:   "__Type",
 9570		Field:    field,
 9571		Args:     nil,
 9572		IsMethod: true,
 9573	}
 9574
 9575	ctx = graphql.WithFieldContext(ctx, fc)
 9576	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9577		ctx = rctx // use context from middleware stack in children
 9578		return obj.Kind(), nil
 9579	})
 9580	if err != nil {
 9581		ec.Error(ctx, err)
 9582		return graphql.Null
 9583	}
 9584	if resTmp == nil {
 9585		if !graphql.HasFieldError(ctx, fc) {
 9586			ec.Errorf(ctx, "must not be null")
 9587		}
 9588		return graphql.Null
 9589	}
 9590	res := resTmp.(string)
 9591	fc.Result = res
 9592	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 9593}
 9594
 9595func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9596	defer func() {
 9597		if r := recover(); r != nil {
 9598			ec.Error(ctx, ec.Recover(ctx, r))
 9599			ret = graphql.Null
 9600		}
 9601	}()
 9602	fc := &graphql.FieldContext{
 9603		Object:   "__Type",
 9604		Field:    field,
 9605		Args:     nil,
 9606		IsMethod: true,
 9607	}
 9608
 9609	ctx = graphql.WithFieldContext(ctx, fc)
 9610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9611		ctx = rctx // use context from middleware stack in children
 9612		return obj.Name(), nil
 9613	})
 9614	if err != nil {
 9615		ec.Error(ctx, err)
 9616		return graphql.Null
 9617	}
 9618	if resTmp == nil {
 9619		return graphql.Null
 9620	}
 9621	res := resTmp.(*string)
 9622	fc.Result = res
 9623	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9624}
 9625
 9626func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9627	defer func() {
 9628		if r := recover(); r != nil {
 9629			ec.Error(ctx, ec.Recover(ctx, r))
 9630			ret = graphql.Null
 9631		}
 9632	}()
 9633	fc := &graphql.FieldContext{
 9634		Object:   "__Type",
 9635		Field:    field,
 9636		Args:     nil,
 9637		IsMethod: true,
 9638	}
 9639
 9640	ctx = graphql.WithFieldContext(ctx, fc)
 9641	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9642		ctx = rctx // use context from middleware stack in children
 9643		return obj.Description(), nil
 9644	})
 9645	if err != nil {
 9646		ec.Error(ctx, err)
 9647		return graphql.Null
 9648	}
 9649	if resTmp == nil {
 9650		return graphql.Null
 9651	}
 9652	res := resTmp.(string)
 9653	fc.Result = res
 9654	return ec.marshalOString2string(ctx, field.Selections, res)
 9655}
 9656
 9657func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9658	defer func() {
 9659		if r := recover(); r != nil {
 9660			ec.Error(ctx, ec.Recover(ctx, r))
 9661			ret = graphql.Null
 9662		}
 9663	}()
 9664	fc := &graphql.FieldContext{
 9665		Object:   "__Type",
 9666		Field:    field,
 9667		Args:     nil,
 9668		IsMethod: true,
 9669	}
 9670
 9671	ctx = graphql.WithFieldContext(ctx, fc)
 9672	rawArgs := field.ArgumentMap(ec.Variables)
 9673	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 9674	if err != nil {
 9675		ec.Error(ctx, err)
 9676		return graphql.Null
 9677	}
 9678	fc.Args = args
 9679	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9680		ctx = rctx // use context from middleware stack in children
 9681		return obj.Fields(args["includeDeprecated"].(bool)), nil
 9682	})
 9683	if err != nil {
 9684		ec.Error(ctx, err)
 9685		return graphql.Null
 9686	}
 9687	if resTmp == nil {
 9688		return graphql.Null
 9689	}
 9690	res := resTmp.([]introspection.Field)
 9691	fc.Result = res
 9692	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
 9693}
 9694
 9695func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9696	defer func() {
 9697		if r := recover(); r != nil {
 9698			ec.Error(ctx, ec.Recover(ctx, r))
 9699			ret = graphql.Null
 9700		}
 9701	}()
 9702	fc := &graphql.FieldContext{
 9703		Object:   "__Type",
 9704		Field:    field,
 9705		Args:     nil,
 9706		IsMethod: true,
 9707	}
 9708
 9709	ctx = graphql.WithFieldContext(ctx, fc)
 9710	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9711		ctx = rctx // use context from middleware stack in children
 9712		return obj.Interfaces(), nil
 9713	})
 9714	if err != nil {
 9715		ec.Error(ctx, err)
 9716		return graphql.Null
 9717	}
 9718	if resTmp == nil {
 9719		return graphql.Null
 9720	}
 9721	res := resTmp.([]introspection.Type)
 9722	fc.Result = res
 9723	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9724}
 9725
 9726func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9727	defer func() {
 9728		if r := recover(); r != nil {
 9729			ec.Error(ctx, ec.Recover(ctx, r))
 9730			ret = graphql.Null
 9731		}
 9732	}()
 9733	fc := &graphql.FieldContext{
 9734		Object:   "__Type",
 9735		Field:    field,
 9736		Args:     nil,
 9737		IsMethod: true,
 9738	}
 9739
 9740	ctx = graphql.WithFieldContext(ctx, fc)
 9741	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9742		ctx = rctx // use context from middleware stack in children
 9743		return obj.PossibleTypes(), nil
 9744	})
 9745	if err != nil {
 9746		ec.Error(ctx, err)
 9747		return graphql.Null
 9748	}
 9749	if resTmp == nil {
 9750		return graphql.Null
 9751	}
 9752	res := resTmp.([]introspection.Type)
 9753	fc.Result = res
 9754	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9755}
 9756
 9757func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9758	defer func() {
 9759		if r := recover(); r != nil {
 9760			ec.Error(ctx, ec.Recover(ctx, r))
 9761			ret = graphql.Null
 9762		}
 9763	}()
 9764	fc := &graphql.FieldContext{
 9765		Object:   "__Type",
 9766		Field:    field,
 9767		Args:     nil,
 9768		IsMethod: true,
 9769	}
 9770
 9771	ctx = graphql.WithFieldContext(ctx, fc)
 9772	rawArgs := field.ArgumentMap(ec.Variables)
 9773	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
 9774	if err != nil {
 9775		ec.Error(ctx, err)
 9776		return graphql.Null
 9777	}
 9778	fc.Args = args
 9779	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9780		ctx = rctx // use context from middleware stack in children
 9781		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
 9782	})
 9783	if err != nil {
 9784		ec.Error(ctx, err)
 9785		return graphql.Null
 9786	}
 9787	if resTmp == nil {
 9788		return graphql.Null
 9789	}
 9790	res := resTmp.([]introspection.EnumValue)
 9791	fc.Result = res
 9792	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
 9793}
 9794
 9795func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9796	defer func() {
 9797		if r := recover(); r != nil {
 9798			ec.Error(ctx, ec.Recover(ctx, r))
 9799			ret = graphql.Null
 9800		}
 9801	}()
 9802	fc := &graphql.FieldContext{
 9803		Object:   "__Type",
 9804		Field:    field,
 9805		Args:     nil,
 9806		IsMethod: true,
 9807	}
 9808
 9809	ctx = graphql.WithFieldContext(ctx, fc)
 9810	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9811		ctx = rctx // use context from middleware stack in children
 9812		return obj.InputFields(), nil
 9813	})
 9814	if err != nil {
 9815		ec.Error(ctx, err)
 9816		return graphql.Null
 9817	}
 9818	if resTmp == nil {
 9819		return graphql.Null
 9820	}
 9821	res := resTmp.([]introspection.InputValue)
 9822	fc.Result = res
 9823	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9824}
 9825
 9826func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9827	defer func() {
 9828		if r := recover(); r != nil {
 9829			ec.Error(ctx, ec.Recover(ctx, r))
 9830			ret = graphql.Null
 9831		}
 9832	}()
 9833	fc := &graphql.FieldContext{
 9834		Object:   "__Type",
 9835		Field:    field,
 9836		Args:     nil,
 9837		IsMethod: true,
 9838	}
 9839
 9840	ctx = graphql.WithFieldContext(ctx, fc)
 9841	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9842		ctx = rctx // use context from middleware stack in children
 9843		return obj.OfType(), nil
 9844	})
 9845	if err != nil {
 9846		ec.Error(ctx, err)
 9847		return graphql.Null
 9848	}
 9849	if resTmp == nil {
 9850		return graphql.Null
 9851	}
 9852	res := resTmp.(*introspection.Type)
 9853	fc.Result = res
 9854	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9855}
 9856
 9857// endregion **************************** field.gotpl *****************************
 9858
 9859// region    **************************** input.gotpl *****************************
 9860
 9861func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
 9862	var it models.AddCommentInput
 9863	var asMap = obj.(map[string]interface{})
 9864
 9865	for k, v := range asMap {
 9866		switch k {
 9867		case "clientMutationId":
 9868			var err error
 9869			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9870			if err != nil {
 9871				return it, err
 9872			}
 9873		case "repoRef":
 9874			var err error
 9875			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9876			if err != nil {
 9877				return it, err
 9878			}
 9879		case "prefix":
 9880			var err error
 9881			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9882			if err != nil {
 9883				return it, err
 9884			}
 9885		case "message":
 9886			var err error
 9887			it.Message, err = ec.unmarshalNString2string(ctx, v)
 9888			if err != nil {
 9889				return it, err
 9890			}
 9891		case "files":
 9892			var err error
 9893			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
 9894			if err != nil {
 9895				return it, err
 9896			}
 9897		}
 9898	}
 9899
 9900	return it, nil
 9901}
 9902
 9903func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
 9904	var it models.ChangeLabelInput
 9905	var asMap = obj.(map[string]interface{})
 9906
 9907	for k, v := range asMap {
 9908		switch k {
 9909		case "clientMutationId":
 9910			var err error
 9911			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9912			if err != nil {
 9913				return it, err
 9914			}
 9915		case "repoRef":
 9916			var err error
 9917			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9918			if err != nil {
 9919				return it, err
 9920			}
 9921		case "prefix":
 9922			var err error
 9923			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9924			if err != nil {
 9925				return it, err
 9926			}
 9927		case "added":
 9928			var err error
 9929			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9930			if err != nil {
 9931				return it, err
 9932			}
 9933		case "Removed":
 9934			var err error
 9935			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9936			if err != nil {
 9937				return it, err
 9938			}
 9939		}
 9940	}
 9941
 9942	return it, nil
 9943}
 9944
 9945func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
 9946	var it models.CloseBugInput
 9947	var asMap = obj.(map[string]interface{})
 9948
 9949	for k, v := range asMap {
 9950		switch k {
 9951		case "clientMutationId":
 9952			var err error
 9953			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9954			if err != nil {
 9955				return it, err
 9956			}
 9957		case "repoRef":
 9958			var err error
 9959			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9960			if err != nil {
 9961				return it, err
 9962			}
 9963		case "prefix":
 9964			var err error
 9965			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9966			if err != nil {
 9967				return it, err
 9968			}
 9969		}
 9970	}
 9971
 9972	return it, nil
 9973}
 9974
 9975func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
 9976	var it models.NewBugInput
 9977	var asMap = obj.(map[string]interface{})
 9978
 9979	for k, v := range asMap {
 9980		switch k {
 9981		case "clientMutationId":
 9982			var err error
 9983			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9984			if err != nil {
 9985				return it, err
 9986			}
 9987		case "repoRef":
 9988			var err error
 9989			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9990			if err != nil {
 9991				return it, err
 9992			}
 9993		case "title":
 9994			var err error
 9995			it.Title, err = ec.unmarshalNString2string(ctx, v)
 9996			if err != nil {
 9997				return it, err
 9998			}
 9999		case "message":
10000			var err error
10001			it.Message, err = ec.unmarshalNString2string(ctx, v)
10002			if err != nil {
10003				return it, err
10004			}
10005		case "files":
10006			var err error
10007			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10008			if err != nil {
10009				return it, err
10010			}
10011		}
10012	}
10013
10014	return it, nil
10015}
10016
10017func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10018	var it models.OpenBugInput
10019	var asMap = obj.(map[string]interface{})
10020
10021	for k, v := range asMap {
10022		switch k {
10023		case "clientMutationId":
10024			var err error
10025			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10026			if err != nil {
10027				return it, err
10028			}
10029		case "repoRef":
10030			var err error
10031			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10032			if err != nil {
10033				return it, err
10034			}
10035		case "prefix":
10036			var err error
10037			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10038			if err != nil {
10039				return it, err
10040			}
10041		}
10042	}
10043
10044	return it, nil
10045}
10046
10047func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10048	var it models.SetTitleInput
10049	var asMap = obj.(map[string]interface{})
10050
10051	for k, v := range asMap {
10052		switch k {
10053		case "clientMutationId":
10054			var err error
10055			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10056			if err != nil {
10057				return it, err
10058			}
10059		case "repoRef":
10060			var err error
10061			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10062			if err != nil {
10063				return it, err
10064			}
10065		case "prefix":
10066			var err error
10067			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10068			if err != nil {
10069				return it, err
10070			}
10071		case "title":
10072			var err error
10073			it.Title, err = ec.unmarshalNString2string(ctx, v)
10074			if err != nil {
10075				return it, err
10076			}
10077		}
10078	}
10079
10080	return it, nil
10081}
10082
10083// endregion **************************** input.gotpl *****************************
10084
10085// region    ************************** interface.gotpl ***************************
10086
10087func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10088	switch obj := (obj).(type) {
10089	case nil:
10090		return graphql.Null
10091	case bug.Comment:
10092		return ec._Comment(ctx, sel, &obj)
10093	case *bug.Comment:
10094		if obj == nil {
10095			return graphql.Null
10096		}
10097		return ec._Comment(ctx, sel, obj)
10098	case models.BugWrapper:
10099		if obj == nil {
10100			return graphql.Null
10101		}
10102		return ec._Bug(ctx, sel, obj)
10103	case *bug.CreateOperation:
10104		if obj == nil {
10105			return graphql.Null
10106		}
10107		return ec._CreateOperation(ctx, sel, obj)
10108	case *bug.SetTitleOperation:
10109		if obj == nil {
10110			return graphql.Null
10111		}
10112		return ec._SetTitleOperation(ctx, sel, obj)
10113	case *bug.AddCommentOperation:
10114		if obj == nil {
10115			return graphql.Null
10116		}
10117		return ec._AddCommentOperation(ctx, sel, obj)
10118	case *bug.EditCommentOperation:
10119		if obj == nil {
10120			return graphql.Null
10121		}
10122		return ec._EditCommentOperation(ctx, sel, obj)
10123	case *bug.SetStatusOperation:
10124		if obj == nil {
10125			return graphql.Null
10126		}
10127		return ec._SetStatusOperation(ctx, sel, obj)
10128	case *bug.LabelChangeOperation:
10129		if obj == nil {
10130			return graphql.Null
10131		}
10132		return ec._LabelChangeOperation(ctx, sel, obj)
10133	case *bug.CreateTimelineItem:
10134		if obj == nil {
10135			return graphql.Null
10136		}
10137		return ec._CreateTimelineItem(ctx, sel, obj)
10138	case *bug.AddCommentTimelineItem:
10139		if obj == nil {
10140			return graphql.Null
10141		}
10142		return ec._AddCommentTimelineItem(ctx, sel, obj)
10143	case *bug.LabelChangeTimelineItem:
10144		if obj == nil {
10145			return graphql.Null
10146		}
10147		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10148	case *bug.SetStatusTimelineItem:
10149		if obj == nil {
10150			return graphql.Null
10151		}
10152		return ec._SetStatusTimelineItem(ctx, sel, obj)
10153	case *bug.SetTitleTimelineItem:
10154		if obj == nil {
10155			return graphql.Null
10156		}
10157		return ec._SetTitleTimelineItem(ctx, sel, obj)
10158	default:
10159		panic(fmt.Errorf("unexpected type %T", obj))
10160	}
10161}
10162
10163func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10164	switch obj := (obj).(type) {
10165	case nil:
10166		return graphql.Null
10167	case *bug.CreateOperation:
10168		if obj == nil {
10169			return graphql.Null
10170		}
10171		return ec._CreateOperation(ctx, sel, obj)
10172	case *bug.SetTitleOperation:
10173		if obj == nil {
10174			return graphql.Null
10175		}
10176		return ec._SetTitleOperation(ctx, sel, obj)
10177	case *bug.AddCommentOperation:
10178		if obj == nil {
10179			return graphql.Null
10180		}
10181		return ec._AddCommentOperation(ctx, sel, obj)
10182	case *bug.EditCommentOperation:
10183		if obj == nil {
10184			return graphql.Null
10185		}
10186		return ec._EditCommentOperation(ctx, sel, obj)
10187	case *bug.SetStatusOperation:
10188		if obj == nil {
10189			return graphql.Null
10190		}
10191		return ec._SetStatusOperation(ctx, sel, obj)
10192	case *bug.LabelChangeOperation:
10193		if obj == nil {
10194			return graphql.Null
10195		}
10196		return ec._LabelChangeOperation(ctx, sel, obj)
10197	default:
10198		panic(fmt.Errorf("unexpected type %T", obj))
10199	}
10200}
10201
10202func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10203	switch obj := (obj).(type) {
10204	case nil:
10205		return graphql.Null
10206	case *bug.CreateTimelineItem:
10207		if obj == nil {
10208			return graphql.Null
10209		}
10210		return ec._CreateTimelineItem(ctx, sel, obj)
10211	case *bug.AddCommentTimelineItem:
10212		if obj == nil {
10213			return graphql.Null
10214		}
10215		return ec._AddCommentTimelineItem(ctx, sel, obj)
10216	case bug.LabelChangeTimelineItem:
10217		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10218	case *bug.LabelChangeTimelineItem:
10219		if obj == nil {
10220			return graphql.Null
10221		}
10222		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10223	case bug.SetStatusTimelineItem:
10224		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10225	case *bug.SetStatusTimelineItem:
10226		if obj == nil {
10227			return graphql.Null
10228		}
10229		return ec._SetStatusTimelineItem(ctx, sel, obj)
10230	case bug.SetTitleTimelineItem:
10231		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10232	case *bug.SetTitleTimelineItem:
10233		if obj == nil {
10234			return graphql.Null
10235		}
10236		return ec._SetTitleTimelineItem(ctx, sel, obj)
10237	default:
10238		panic(fmt.Errorf("unexpected type %T", obj))
10239	}
10240}
10241
10242// endregion ************************** interface.gotpl ***************************
10243
10244// region    **************************** object.gotpl ****************************
10245
10246var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10247
10248func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10249	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10250
10251	out := graphql.NewFieldSet(fields)
10252	var invalids uint32
10253	for i, field := range fields {
10254		switch field.Name {
10255		case "__typename":
10256			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10257		case "id":
10258			field := field
10259			out.Concurrently(i, func() (res graphql.Marshaler) {
10260				defer func() {
10261					if r := recover(); r != nil {
10262						ec.Error(ctx, ec.Recover(ctx, r))
10263					}
10264				}()
10265				res = ec._AddCommentOperation_id(ctx, field, obj)
10266				if res == graphql.Null {
10267					atomic.AddUint32(&invalids, 1)
10268				}
10269				return res
10270			})
10271		case "author":
10272			field := field
10273			out.Concurrently(i, func() (res graphql.Marshaler) {
10274				defer func() {
10275					if r := recover(); r != nil {
10276						ec.Error(ctx, ec.Recover(ctx, r))
10277					}
10278				}()
10279				res = ec._AddCommentOperation_author(ctx, field, obj)
10280				if res == graphql.Null {
10281					atomic.AddUint32(&invalids, 1)
10282				}
10283				return res
10284			})
10285		case "date":
10286			field := field
10287			out.Concurrently(i, func() (res graphql.Marshaler) {
10288				defer func() {
10289					if r := recover(); r != nil {
10290						ec.Error(ctx, ec.Recover(ctx, r))
10291					}
10292				}()
10293				res = ec._AddCommentOperation_date(ctx, field, obj)
10294				if res == graphql.Null {
10295					atomic.AddUint32(&invalids, 1)
10296				}
10297				return res
10298			})
10299		case "message":
10300			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10301			if out.Values[i] == graphql.Null {
10302				atomic.AddUint32(&invalids, 1)
10303			}
10304		case "files":
10305			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10306			if out.Values[i] == graphql.Null {
10307				atomic.AddUint32(&invalids, 1)
10308			}
10309		default:
10310			panic("unknown field " + strconv.Quote(field.Name))
10311		}
10312	}
10313	out.Dispatch()
10314	if invalids > 0 {
10315		return graphql.Null
10316	}
10317	return out
10318}
10319
10320var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10321
10322func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10323	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10324
10325	out := graphql.NewFieldSet(fields)
10326	var invalids uint32
10327	for i, field := range fields {
10328		switch field.Name {
10329		case "__typename":
10330			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10331		case "clientMutationId":
10332			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10333		case "bug":
10334			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10335			if out.Values[i] == graphql.Null {
10336				invalids++
10337			}
10338		case "operation":
10339			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10340			if out.Values[i] == graphql.Null {
10341				invalids++
10342			}
10343		default:
10344			panic("unknown field " + strconv.Quote(field.Name))
10345		}
10346	}
10347	out.Dispatch()
10348	if invalids > 0 {
10349		return graphql.Null
10350	}
10351	return out
10352}
10353
10354var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10355
10356func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10357	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10358
10359	out := graphql.NewFieldSet(fields)
10360	var invalids uint32
10361	for i, field := range fields {
10362		switch field.Name {
10363		case "__typename":
10364			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10365		case "id":
10366			field := field
10367			out.Concurrently(i, func() (res graphql.Marshaler) {
10368				defer func() {
10369					if r := recover(); r != nil {
10370						ec.Error(ctx, ec.Recover(ctx, r))
10371					}
10372				}()
10373				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10374				if res == graphql.Null {
10375					atomic.AddUint32(&invalids, 1)
10376				}
10377				return res
10378			})
10379		case "author":
10380			field := field
10381			out.Concurrently(i, func() (res graphql.Marshaler) {
10382				defer func() {
10383					if r := recover(); r != nil {
10384						ec.Error(ctx, ec.Recover(ctx, r))
10385					}
10386				}()
10387				res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10388				if res == graphql.Null {
10389					atomic.AddUint32(&invalids, 1)
10390				}
10391				return res
10392			})
10393		case "message":
10394			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10395			if out.Values[i] == graphql.Null {
10396				atomic.AddUint32(&invalids, 1)
10397			}
10398		case "messageIsEmpty":
10399			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10400			if out.Values[i] == graphql.Null {
10401				atomic.AddUint32(&invalids, 1)
10402			}
10403		case "files":
10404			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10405			if out.Values[i] == graphql.Null {
10406				atomic.AddUint32(&invalids, 1)
10407			}
10408		case "createdAt":
10409			field := field
10410			out.Concurrently(i, func() (res graphql.Marshaler) {
10411				defer func() {
10412					if r := recover(); r != nil {
10413						ec.Error(ctx, ec.Recover(ctx, r))
10414					}
10415				}()
10416				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10417				if res == graphql.Null {
10418					atomic.AddUint32(&invalids, 1)
10419				}
10420				return res
10421			})
10422		case "lastEdit":
10423			field := field
10424			out.Concurrently(i, func() (res graphql.Marshaler) {
10425				defer func() {
10426					if r := recover(); r != nil {
10427						ec.Error(ctx, ec.Recover(ctx, r))
10428					}
10429				}()
10430				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10431				if res == graphql.Null {
10432					atomic.AddUint32(&invalids, 1)
10433				}
10434				return res
10435			})
10436		case "edited":
10437			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10438			if out.Values[i] == graphql.Null {
10439				atomic.AddUint32(&invalids, 1)
10440			}
10441		case "history":
10442			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10443			if out.Values[i] == graphql.Null {
10444				atomic.AddUint32(&invalids, 1)
10445			}
10446		default:
10447			panic("unknown field " + strconv.Quote(field.Name))
10448		}
10449	}
10450	out.Dispatch()
10451	if invalids > 0 {
10452		return graphql.Null
10453	}
10454	return out
10455}
10456
10457var bugImplementors = []string{"Bug", "Authored"}
10458
10459func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10460	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10461
10462	out := graphql.NewFieldSet(fields)
10463	var invalids uint32
10464	for i, field := range fields {
10465		switch field.Name {
10466		case "__typename":
10467			out.Values[i] = graphql.MarshalString("Bug")
10468		case "id":
10469			field := field
10470			out.Concurrently(i, func() (res graphql.Marshaler) {
10471				defer func() {
10472					if r := recover(); r != nil {
10473						ec.Error(ctx, ec.Recover(ctx, r))
10474					}
10475				}()
10476				res = ec._Bug_id(ctx, field, obj)
10477				if res == graphql.Null {
10478					atomic.AddUint32(&invalids, 1)
10479				}
10480				return res
10481			})
10482		case "humanId":
10483			field := field
10484			out.Concurrently(i, func() (res graphql.Marshaler) {
10485				defer func() {
10486					if r := recover(); r != nil {
10487						ec.Error(ctx, ec.Recover(ctx, r))
10488					}
10489				}()
10490				res = ec._Bug_humanId(ctx, field, obj)
10491				if res == graphql.Null {
10492					atomic.AddUint32(&invalids, 1)
10493				}
10494				return res
10495			})
10496		case "status":
10497			field := field
10498			out.Concurrently(i, func() (res graphql.Marshaler) {
10499				defer func() {
10500					if r := recover(); r != nil {
10501						ec.Error(ctx, ec.Recover(ctx, r))
10502					}
10503				}()
10504				res = ec._Bug_status(ctx, field, obj)
10505				if res == graphql.Null {
10506					atomic.AddUint32(&invalids, 1)
10507				}
10508				return res
10509			})
10510		case "title":
10511			out.Values[i] = ec._Bug_title(ctx, field, obj)
10512			if out.Values[i] == graphql.Null {
10513				atomic.AddUint32(&invalids, 1)
10514			}
10515		case "labels":
10516			out.Values[i] = ec._Bug_labels(ctx, field, obj)
10517			if out.Values[i] == graphql.Null {
10518				atomic.AddUint32(&invalids, 1)
10519			}
10520		case "author":
10521			out.Values[i] = ec._Bug_author(ctx, field, obj)
10522			if out.Values[i] == graphql.Null {
10523				atomic.AddUint32(&invalids, 1)
10524			}
10525		case "createdAt":
10526			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10527			if out.Values[i] == graphql.Null {
10528				atomic.AddUint32(&invalids, 1)
10529			}
10530		case "lastEdit":
10531			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10532			if out.Values[i] == graphql.Null {
10533				atomic.AddUint32(&invalids, 1)
10534			}
10535		case "actors":
10536			field := field
10537			out.Concurrently(i, func() (res graphql.Marshaler) {
10538				defer func() {
10539					if r := recover(); r != nil {
10540						ec.Error(ctx, ec.Recover(ctx, r))
10541					}
10542				}()
10543				res = ec._Bug_actors(ctx, field, obj)
10544				if res == graphql.Null {
10545					atomic.AddUint32(&invalids, 1)
10546				}
10547				return res
10548			})
10549		case "participants":
10550			field := field
10551			out.Concurrently(i, func() (res graphql.Marshaler) {
10552				defer func() {
10553					if r := recover(); r != nil {
10554						ec.Error(ctx, ec.Recover(ctx, r))
10555					}
10556				}()
10557				res = ec._Bug_participants(ctx, field, obj)
10558				if res == graphql.Null {
10559					atomic.AddUint32(&invalids, 1)
10560				}
10561				return res
10562			})
10563		case "comments":
10564			field := field
10565			out.Concurrently(i, func() (res graphql.Marshaler) {
10566				defer func() {
10567					if r := recover(); r != nil {
10568						ec.Error(ctx, ec.Recover(ctx, r))
10569					}
10570				}()
10571				res = ec._Bug_comments(ctx, field, obj)
10572				if res == graphql.Null {
10573					atomic.AddUint32(&invalids, 1)
10574				}
10575				return res
10576			})
10577		case "timeline":
10578			field := field
10579			out.Concurrently(i, func() (res graphql.Marshaler) {
10580				defer func() {
10581					if r := recover(); r != nil {
10582						ec.Error(ctx, ec.Recover(ctx, r))
10583					}
10584				}()
10585				res = ec._Bug_timeline(ctx, field, obj)
10586				if res == graphql.Null {
10587					atomic.AddUint32(&invalids, 1)
10588				}
10589				return res
10590			})
10591		case "operations":
10592			field := field
10593			out.Concurrently(i, func() (res graphql.Marshaler) {
10594				defer func() {
10595					if r := recover(); r != nil {
10596						ec.Error(ctx, ec.Recover(ctx, r))
10597					}
10598				}()
10599				res = ec._Bug_operations(ctx, field, obj)
10600				if res == graphql.Null {
10601					atomic.AddUint32(&invalids, 1)
10602				}
10603				return res
10604			})
10605		default:
10606			panic("unknown field " + strconv.Quote(field.Name))
10607		}
10608	}
10609	out.Dispatch()
10610	if invalids > 0 {
10611		return graphql.Null
10612	}
10613	return out
10614}
10615
10616var bugConnectionImplementors = []string{"BugConnection"}
10617
10618func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10619	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10620
10621	out := graphql.NewFieldSet(fields)
10622	var invalids uint32
10623	for i, field := range fields {
10624		switch field.Name {
10625		case "__typename":
10626			out.Values[i] = graphql.MarshalString("BugConnection")
10627		case "edges":
10628			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10629			if out.Values[i] == graphql.Null {
10630				invalids++
10631			}
10632		case "nodes":
10633			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10634			if out.Values[i] == graphql.Null {
10635				invalids++
10636			}
10637		case "pageInfo":
10638			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10639			if out.Values[i] == graphql.Null {
10640				invalids++
10641			}
10642		case "totalCount":
10643			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
10644			if out.Values[i] == graphql.Null {
10645				invalids++
10646			}
10647		default:
10648			panic("unknown field " + strconv.Quote(field.Name))
10649		}
10650	}
10651	out.Dispatch()
10652	if invalids > 0 {
10653		return graphql.Null
10654	}
10655	return out
10656}
10657
10658var bugEdgeImplementors = []string{"BugEdge"}
10659
10660func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
10661	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
10662
10663	out := graphql.NewFieldSet(fields)
10664	var invalids uint32
10665	for i, field := range fields {
10666		switch field.Name {
10667		case "__typename":
10668			out.Values[i] = graphql.MarshalString("BugEdge")
10669		case "cursor":
10670			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
10671			if out.Values[i] == graphql.Null {
10672				invalids++
10673			}
10674		case "node":
10675			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
10676			if out.Values[i] == graphql.Null {
10677				invalids++
10678			}
10679		default:
10680			panic("unknown field " + strconv.Quote(field.Name))
10681		}
10682	}
10683	out.Dispatch()
10684	if invalids > 0 {
10685		return graphql.Null
10686	}
10687	return out
10688}
10689
10690var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
10691
10692func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
10693	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
10694
10695	out := graphql.NewFieldSet(fields)
10696	var invalids uint32
10697	for i, field := range fields {
10698		switch field.Name {
10699		case "__typename":
10700			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
10701		case "clientMutationId":
10702			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
10703		case "bug":
10704			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
10705			if out.Values[i] == graphql.Null {
10706				invalids++
10707			}
10708		case "operation":
10709			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
10710			if out.Values[i] == graphql.Null {
10711				invalids++
10712			}
10713		case "results":
10714			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
10715			if out.Values[i] == graphql.Null {
10716				invalids++
10717			}
10718		default:
10719			panic("unknown field " + strconv.Quote(field.Name))
10720		}
10721	}
10722	out.Dispatch()
10723	if invalids > 0 {
10724		return graphql.Null
10725	}
10726	return out
10727}
10728
10729var closeBugPayloadImplementors = []string{"CloseBugPayload"}
10730
10731func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
10732	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
10733
10734	out := graphql.NewFieldSet(fields)
10735	var invalids uint32
10736	for i, field := range fields {
10737		switch field.Name {
10738		case "__typename":
10739			out.Values[i] = graphql.MarshalString("CloseBugPayload")
10740		case "clientMutationId":
10741			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
10742		case "bug":
10743			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
10744			if out.Values[i] == graphql.Null {
10745				invalids++
10746			}
10747		case "operation":
10748			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
10749			if out.Values[i] == graphql.Null {
10750				invalids++
10751			}
10752		default:
10753			panic("unknown field " + strconv.Quote(field.Name))
10754		}
10755	}
10756	out.Dispatch()
10757	if invalids > 0 {
10758		return graphql.Null
10759	}
10760	return out
10761}
10762
10763var colorImplementors = []string{"Color"}
10764
10765func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
10766	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
10767
10768	out := graphql.NewFieldSet(fields)
10769	var invalids uint32
10770	for i, field := range fields {
10771		switch field.Name {
10772		case "__typename":
10773			out.Values[i] = graphql.MarshalString("Color")
10774		case "R":
10775			field := field
10776			out.Concurrently(i, func() (res graphql.Marshaler) {
10777				defer func() {
10778					if r := recover(); r != nil {
10779						ec.Error(ctx, ec.Recover(ctx, r))
10780					}
10781				}()
10782				res = ec._Color_R(ctx, field, obj)
10783				if res == graphql.Null {
10784					atomic.AddUint32(&invalids, 1)
10785				}
10786				return res
10787			})
10788		case "G":
10789			field := field
10790			out.Concurrently(i, func() (res graphql.Marshaler) {
10791				defer func() {
10792					if r := recover(); r != nil {
10793						ec.Error(ctx, ec.Recover(ctx, r))
10794					}
10795				}()
10796				res = ec._Color_G(ctx, field, obj)
10797				if res == graphql.Null {
10798					atomic.AddUint32(&invalids, 1)
10799				}
10800				return res
10801			})
10802		case "B":
10803			field := field
10804			out.Concurrently(i, func() (res graphql.Marshaler) {
10805				defer func() {
10806					if r := recover(); r != nil {
10807						ec.Error(ctx, ec.Recover(ctx, r))
10808					}
10809				}()
10810				res = ec._Color_B(ctx, field, obj)
10811				if res == graphql.Null {
10812					atomic.AddUint32(&invalids, 1)
10813				}
10814				return res
10815			})
10816		default:
10817			panic("unknown field " + strconv.Quote(field.Name))
10818		}
10819	}
10820	out.Dispatch()
10821	if invalids > 0 {
10822		return graphql.Null
10823	}
10824	return out
10825}
10826
10827var commentImplementors = []string{"Comment", "Authored"}
10828
10829func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
10830	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
10831
10832	out := graphql.NewFieldSet(fields)
10833	var invalids uint32
10834	for i, field := range fields {
10835		switch field.Name {
10836		case "__typename":
10837			out.Values[i] = graphql.MarshalString("Comment")
10838		case "author":
10839			field := field
10840			out.Concurrently(i, func() (res graphql.Marshaler) {
10841				defer func() {
10842					if r := recover(); r != nil {
10843						ec.Error(ctx, ec.Recover(ctx, r))
10844					}
10845				}()
10846				res = ec._Comment_author(ctx, field, obj)
10847				if res == graphql.Null {
10848					atomic.AddUint32(&invalids, 1)
10849				}
10850				return res
10851			})
10852		case "message":
10853			out.Values[i] = ec._Comment_message(ctx, field, obj)
10854			if out.Values[i] == graphql.Null {
10855				atomic.AddUint32(&invalids, 1)
10856			}
10857		case "files":
10858			out.Values[i] = ec._Comment_files(ctx, field, obj)
10859			if out.Values[i] == graphql.Null {
10860				atomic.AddUint32(&invalids, 1)
10861			}
10862		default:
10863			panic("unknown field " + strconv.Quote(field.Name))
10864		}
10865	}
10866	out.Dispatch()
10867	if invalids > 0 {
10868		return graphql.Null
10869	}
10870	return out
10871}
10872
10873var commentConnectionImplementors = []string{"CommentConnection"}
10874
10875func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
10876	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
10877
10878	out := graphql.NewFieldSet(fields)
10879	var invalids uint32
10880	for i, field := range fields {
10881		switch field.Name {
10882		case "__typename":
10883			out.Values[i] = graphql.MarshalString("CommentConnection")
10884		case "edges":
10885			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
10886			if out.Values[i] == graphql.Null {
10887				invalids++
10888			}
10889		case "nodes":
10890			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
10891			if out.Values[i] == graphql.Null {
10892				invalids++
10893			}
10894		case "pageInfo":
10895			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
10896			if out.Values[i] == graphql.Null {
10897				invalids++
10898			}
10899		case "totalCount":
10900			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
10901			if out.Values[i] == graphql.Null {
10902				invalids++
10903			}
10904		default:
10905			panic("unknown field " + strconv.Quote(field.Name))
10906		}
10907	}
10908	out.Dispatch()
10909	if invalids > 0 {
10910		return graphql.Null
10911	}
10912	return out
10913}
10914
10915var commentEdgeImplementors = []string{"CommentEdge"}
10916
10917func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
10918	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
10919
10920	out := graphql.NewFieldSet(fields)
10921	var invalids uint32
10922	for i, field := range fields {
10923		switch field.Name {
10924		case "__typename":
10925			out.Values[i] = graphql.MarshalString("CommentEdge")
10926		case "cursor":
10927			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
10928			if out.Values[i] == graphql.Null {
10929				invalids++
10930			}
10931		case "node":
10932			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
10933			if out.Values[i] == graphql.Null {
10934				invalids++
10935			}
10936		default:
10937			panic("unknown field " + strconv.Quote(field.Name))
10938		}
10939	}
10940	out.Dispatch()
10941	if invalids > 0 {
10942		return graphql.Null
10943	}
10944	return out
10945}
10946
10947var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
10948
10949func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
10950	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
10951
10952	out := graphql.NewFieldSet(fields)
10953	var invalids uint32
10954	for i, field := range fields {
10955		switch field.Name {
10956		case "__typename":
10957			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
10958		case "message":
10959			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
10960			if out.Values[i] == graphql.Null {
10961				atomic.AddUint32(&invalids, 1)
10962			}
10963		case "date":
10964			field := field
10965			out.Concurrently(i, func() (res graphql.Marshaler) {
10966				defer func() {
10967					if r := recover(); r != nil {
10968						ec.Error(ctx, ec.Recover(ctx, r))
10969					}
10970				}()
10971				res = ec._CommentHistoryStep_date(ctx, field, obj)
10972				if res == graphql.Null {
10973					atomic.AddUint32(&invalids, 1)
10974				}
10975				return res
10976			})
10977		default:
10978			panic("unknown field " + strconv.Quote(field.Name))
10979		}
10980	}
10981	out.Dispatch()
10982	if invalids > 0 {
10983		return graphql.Null
10984	}
10985	return out
10986}
10987
10988var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
10989
10990func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
10991	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
10992
10993	out := graphql.NewFieldSet(fields)
10994	var invalids uint32
10995	for i, field := range fields {
10996		switch field.Name {
10997		case "__typename":
10998			out.Values[i] = graphql.MarshalString("CreateOperation")
10999		case "id":
11000			field := field
11001			out.Concurrently(i, func() (res graphql.Marshaler) {
11002				defer func() {
11003					if r := recover(); r != nil {
11004						ec.Error(ctx, ec.Recover(ctx, r))
11005					}
11006				}()
11007				res = ec._CreateOperation_id(ctx, field, obj)
11008				if res == graphql.Null {
11009					atomic.AddUint32(&invalids, 1)
11010				}
11011				return res
11012			})
11013		case "author":
11014			field := field
11015			out.Concurrently(i, func() (res graphql.Marshaler) {
11016				defer func() {
11017					if r := recover(); r != nil {
11018						ec.Error(ctx, ec.Recover(ctx, r))
11019					}
11020				}()
11021				res = ec._CreateOperation_author(ctx, field, obj)
11022				if res == graphql.Null {
11023					atomic.AddUint32(&invalids, 1)
11024				}
11025				return res
11026			})
11027		case "date":
11028			field := field
11029			out.Concurrently(i, func() (res graphql.Marshaler) {
11030				defer func() {
11031					if r := recover(); r != nil {
11032						ec.Error(ctx, ec.Recover(ctx, r))
11033					}
11034				}()
11035				res = ec._CreateOperation_date(ctx, field, obj)
11036				if res == graphql.Null {
11037					atomic.AddUint32(&invalids, 1)
11038				}
11039				return res
11040			})
11041		case "title":
11042			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11043			if out.Values[i] == graphql.Null {
11044				atomic.AddUint32(&invalids, 1)
11045			}
11046		case "message":
11047			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11048			if out.Values[i] == graphql.Null {
11049				atomic.AddUint32(&invalids, 1)
11050			}
11051		case "files":
11052			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11053			if out.Values[i] == graphql.Null {
11054				atomic.AddUint32(&invalids, 1)
11055			}
11056		default:
11057			panic("unknown field " + strconv.Quote(field.Name))
11058		}
11059	}
11060	out.Dispatch()
11061	if invalids > 0 {
11062		return graphql.Null
11063	}
11064	return out
11065}
11066
11067var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11068
11069func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11070	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11071
11072	out := graphql.NewFieldSet(fields)
11073	var invalids uint32
11074	for i, field := range fields {
11075		switch field.Name {
11076		case "__typename":
11077			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11078		case "id":
11079			field := field
11080			out.Concurrently(i, func() (res graphql.Marshaler) {
11081				defer func() {
11082					if r := recover(); r != nil {
11083						ec.Error(ctx, ec.Recover(ctx, r))
11084					}
11085				}()
11086				res = ec._CreateTimelineItem_id(ctx, field, obj)
11087				if res == graphql.Null {
11088					atomic.AddUint32(&invalids, 1)
11089				}
11090				return res
11091			})
11092		case "author":
11093			field := field
11094			out.Concurrently(i, func() (res graphql.Marshaler) {
11095				defer func() {
11096					if r := recover(); r != nil {
11097						ec.Error(ctx, ec.Recover(ctx, r))
11098					}
11099				}()
11100				res = ec._CreateTimelineItem_author(ctx, field, obj)
11101				if res == graphql.Null {
11102					atomic.AddUint32(&invalids, 1)
11103				}
11104				return res
11105			})
11106		case "message":
11107			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11108			if out.Values[i] == graphql.Null {
11109				atomic.AddUint32(&invalids, 1)
11110			}
11111		case "messageIsEmpty":
11112			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11113			if out.Values[i] == graphql.Null {
11114				atomic.AddUint32(&invalids, 1)
11115			}
11116		case "files":
11117			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11118			if out.Values[i] == graphql.Null {
11119				atomic.AddUint32(&invalids, 1)
11120			}
11121		case "createdAt":
11122			field := field
11123			out.Concurrently(i, func() (res graphql.Marshaler) {
11124				defer func() {
11125					if r := recover(); r != nil {
11126						ec.Error(ctx, ec.Recover(ctx, r))
11127					}
11128				}()
11129				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11130				if res == graphql.Null {
11131					atomic.AddUint32(&invalids, 1)
11132				}
11133				return res
11134			})
11135		case "lastEdit":
11136			field := field
11137			out.Concurrently(i, func() (res graphql.Marshaler) {
11138				defer func() {
11139					if r := recover(); r != nil {
11140						ec.Error(ctx, ec.Recover(ctx, r))
11141					}
11142				}()
11143				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11144				if res == graphql.Null {
11145					atomic.AddUint32(&invalids, 1)
11146				}
11147				return res
11148			})
11149		case "edited":
11150			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11151			if out.Values[i] == graphql.Null {
11152				atomic.AddUint32(&invalids, 1)
11153			}
11154		case "history":
11155			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11156			if out.Values[i] == graphql.Null {
11157				atomic.AddUint32(&invalids, 1)
11158			}
11159		default:
11160			panic("unknown field " + strconv.Quote(field.Name))
11161		}
11162	}
11163	out.Dispatch()
11164	if invalids > 0 {
11165		return graphql.Null
11166	}
11167	return out
11168}
11169
11170var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11171
11172func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11173	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11174
11175	out := graphql.NewFieldSet(fields)
11176	var invalids uint32
11177	for i, field := range fields {
11178		switch field.Name {
11179		case "__typename":
11180			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11181		case "id":
11182			field := field
11183			out.Concurrently(i, func() (res graphql.Marshaler) {
11184				defer func() {
11185					if r := recover(); r != nil {
11186						ec.Error(ctx, ec.Recover(ctx, r))
11187					}
11188				}()
11189				res = ec._EditCommentOperation_id(ctx, field, obj)
11190				if res == graphql.Null {
11191					atomic.AddUint32(&invalids, 1)
11192				}
11193				return res
11194			})
11195		case "author":
11196			field := field
11197			out.Concurrently(i, func() (res graphql.Marshaler) {
11198				defer func() {
11199					if r := recover(); r != nil {
11200						ec.Error(ctx, ec.Recover(ctx, r))
11201					}
11202				}()
11203				res = ec._EditCommentOperation_author(ctx, field, obj)
11204				if res == graphql.Null {
11205					atomic.AddUint32(&invalids, 1)
11206				}
11207				return res
11208			})
11209		case "date":
11210			field := field
11211			out.Concurrently(i, func() (res graphql.Marshaler) {
11212				defer func() {
11213					if r := recover(); r != nil {
11214						ec.Error(ctx, ec.Recover(ctx, r))
11215					}
11216				}()
11217				res = ec._EditCommentOperation_date(ctx, field, obj)
11218				if res == graphql.Null {
11219					atomic.AddUint32(&invalids, 1)
11220				}
11221				return res
11222			})
11223		case "target":
11224			field := field
11225			out.Concurrently(i, func() (res graphql.Marshaler) {
11226				defer func() {
11227					if r := recover(); r != nil {
11228						ec.Error(ctx, ec.Recover(ctx, r))
11229					}
11230				}()
11231				res = ec._EditCommentOperation_target(ctx, field, obj)
11232				if res == graphql.Null {
11233					atomic.AddUint32(&invalids, 1)
11234				}
11235				return res
11236			})
11237		case "message":
11238			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11239			if out.Values[i] == graphql.Null {
11240				atomic.AddUint32(&invalids, 1)
11241			}
11242		case "files":
11243			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11244			if out.Values[i] == graphql.Null {
11245				atomic.AddUint32(&invalids, 1)
11246			}
11247		default:
11248			panic("unknown field " + strconv.Quote(field.Name))
11249		}
11250	}
11251	out.Dispatch()
11252	if invalids > 0 {
11253		return graphql.Null
11254	}
11255	return out
11256}
11257
11258var identityImplementors = []string{"Identity"}
11259
11260func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11261	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11262
11263	out := graphql.NewFieldSet(fields)
11264	var invalids uint32
11265	for i, field := range fields {
11266		switch field.Name {
11267		case "__typename":
11268			out.Values[i] = graphql.MarshalString("Identity")
11269		case "id":
11270			field := field
11271			out.Concurrently(i, func() (res graphql.Marshaler) {
11272				defer func() {
11273					if r := recover(); r != nil {
11274						ec.Error(ctx, ec.Recover(ctx, r))
11275					}
11276				}()
11277				res = ec._Identity_id(ctx, field, obj)
11278				if res == graphql.Null {
11279					atomic.AddUint32(&invalids, 1)
11280				}
11281				return res
11282			})
11283		case "humanId":
11284			field := field
11285			out.Concurrently(i, func() (res graphql.Marshaler) {
11286				defer func() {
11287					if r := recover(); r != nil {
11288						ec.Error(ctx, ec.Recover(ctx, r))
11289					}
11290				}()
11291				res = ec._Identity_humanId(ctx, field, obj)
11292				if res == graphql.Null {
11293					atomic.AddUint32(&invalids, 1)
11294				}
11295				return res
11296			})
11297		case "name":
11298			out.Values[i] = ec._Identity_name(ctx, field, obj)
11299		case "email":
11300			out.Values[i] = ec._Identity_email(ctx, field, obj)
11301		case "login":
11302			out.Values[i] = ec._Identity_login(ctx, field, obj)
11303		case "displayName":
11304			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11305			if out.Values[i] == graphql.Null {
11306				atomic.AddUint32(&invalids, 1)
11307			}
11308		case "avatarUrl":
11309			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11310		case "isProtected":
11311			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11312			if out.Values[i] == graphql.Null {
11313				atomic.AddUint32(&invalids, 1)
11314			}
11315		default:
11316			panic("unknown field " + strconv.Quote(field.Name))
11317		}
11318	}
11319	out.Dispatch()
11320	if invalids > 0 {
11321		return graphql.Null
11322	}
11323	return out
11324}
11325
11326var identityConnectionImplementors = []string{"IdentityConnection"}
11327
11328func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11329	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11330
11331	out := graphql.NewFieldSet(fields)
11332	var invalids uint32
11333	for i, field := range fields {
11334		switch field.Name {
11335		case "__typename":
11336			out.Values[i] = graphql.MarshalString("IdentityConnection")
11337		case "edges":
11338			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11339			if out.Values[i] == graphql.Null {
11340				invalids++
11341			}
11342		case "nodes":
11343			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11344			if out.Values[i] == graphql.Null {
11345				invalids++
11346			}
11347		case "pageInfo":
11348			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11349			if out.Values[i] == graphql.Null {
11350				invalids++
11351			}
11352		case "totalCount":
11353			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11354			if out.Values[i] == graphql.Null {
11355				invalids++
11356			}
11357		default:
11358			panic("unknown field " + strconv.Quote(field.Name))
11359		}
11360	}
11361	out.Dispatch()
11362	if invalids > 0 {
11363		return graphql.Null
11364	}
11365	return out
11366}
11367
11368var identityEdgeImplementors = []string{"IdentityEdge"}
11369
11370func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11371	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11372
11373	out := graphql.NewFieldSet(fields)
11374	var invalids uint32
11375	for i, field := range fields {
11376		switch field.Name {
11377		case "__typename":
11378			out.Values[i] = graphql.MarshalString("IdentityEdge")
11379		case "cursor":
11380			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11381			if out.Values[i] == graphql.Null {
11382				invalids++
11383			}
11384		case "node":
11385			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11386			if out.Values[i] == graphql.Null {
11387				invalids++
11388			}
11389		default:
11390			panic("unknown field " + strconv.Quote(field.Name))
11391		}
11392	}
11393	out.Dispatch()
11394	if invalids > 0 {
11395		return graphql.Null
11396	}
11397	return out
11398}
11399
11400var labelImplementors = []string{"Label"}
11401
11402func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11403	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11404
11405	out := graphql.NewFieldSet(fields)
11406	var invalids uint32
11407	for i, field := range fields {
11408		switch field.Name {
11409		case "__typename":
11410			out.Values[i] = graphql.MarshalString("Label")
11411		case "name":
11412			field := field
11413			out.Concurrently(i, func() (res graphql.Marshaler) {
11414				defer func() {
11415					if r := recover(); r != nil {
11416						ec.Error(ctx, ec.Recover(ctx, r))
11417					}
11418				}()
11419				res = ec._Label_name(ctx, field, obj)
11420				if res == graphql.Null {
11421					atomic.AddUint32(&invalids, 1)
11422				}
11423				return res
11424			})
11425		case "color":
11426			field := field
11427			out.Concurrently(i, func() (res graphql.Marshaler) {
11428				defer func() {
11429					if r := recover(); r != nil {
11430						ec.Error(ctx, ec.Recover(ctx, r))
11431					}
11432				}()
11433				res = ec._Label_color(ctx, field, obj)
11434				if res == graphql.Null {
11435					atomic.AddUint32(&invalids, 1)
11436				}
11437				return res
11438			})
11439		default:
11440			panic("unknown field " + strconv.Quote(field.Name))
11441		}
11442	}
11443	out.Dispatch()
11444	if invalids > 0 {
11445		return graphql.Null
11446	}
11447	return out
11448}
11449
11450var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11451
11452func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11453	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11454
11455	out := graphql.NewFieldSet(fields)
11456	var invalids uint32
11457	for i, field := range fields {
11458		switch field.Name {
11459		case "__typename":
11460			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11461		case "id":
11462			field := field
11463			out.Concurrently(i, func() (res graphql.Marshaler) {
11464				defer func() {
11465					if r := recover(); r != nil {
11466						ec.Error(ctx, ec.Recover(ctx, r))
11467					}
11468				}()
11469				res = ec._LabelChangeOperation_id(ctx, field, obj)
11470				if res == graphql.Null {
11471					atomic.AddUint32(&invalids, 1)
11472				}
11473				return res
11474			})
11475		case "author":
11476			field := field
11477			out.Concurrently(i, func() (res graphql.Marshaler) {
11478				defer func() {
11479					if r := recover(); r != nil {
11480						ec.Error(ctx, ec.Recover(ctx, r))
11481					}
11482				}()
11483				res = ec._LabelChangeOperation_author(ctx, field, obj)
11484				if res == graphql.Null {
11485					atomic.AddUint32(&invalids, 1)
11486				}
11487				return res
11488			})
11489		case "date":
11490			field := field
11491			out.Concurrently(i, func() (res graphql.Marshaler) {
11492				defer func() {
11493					if r := recover(); r != nil {
11494						ec.Error(ctx, ec.Recover(ctx, r))
11495					}
11496				}()
11497				res = ec._LabelChangeOperation_date(ctx, field, obj)
11498				if res == graphql.Null {
11499					atomic.AddUint32(&invalids, 1)
11500				}
11501				return res
11502			})
11503		case "added":
11504			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11505			if out.Values[i] == graphql.Null {
11506				atomic.AddUint32(&invalids, 1)
11507			}
11508		case "removed":
11509			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11510			if out.Values[i] == graphql.Null {
11511				atomic.AddUint32(&invalids, 1)
11512			}
11513		default:
11514			panic("unknown field " + strconv.Quote(field.Name))
11515		}
11516	}
11517	out.Dispatch()
11518	if invalids > 0 {
11519		return graphql.Null
11520	}
11521	return out
11522}
11523
11524var labelChangeResultImplementors = []string{"LabelChangeResult"}
11525
11526func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11527	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11528
11529	out := graphql.NewFieldSet(fields)
11530	var invalids uint32
11531	for i, field := range fields {
11532		switch field.Name {
11533		case "__typename":
11534			out.Values[i] = graphql.MarshalString("LabelChangeResult")
11535		case "label":
11536			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11537			if out.Values[i] == graphql.Null {
11538				atomic.AddUint32(&invalids, 1)
11539			}
11540		case "status":
11541			field := field
11542			out.Concurrently(i, func() (res graphql.Marshaler) {
11543				defer func() {
11544					if r := recover(); r != nil {
11545						ec.Error(ctx, ec.Recover(ctx, r))
11546					}
11547				}()
11548				res = ec._LabelChangeResult_status(ctx, field, obj)
11549				if res == graphql.Null {
11550					atomic.AddUint32(&invalids, 1)
11551				}
11552				return res
11553			})
11554		default:
11555			panic("unknown field " + strconv.Quote(field.Name))
11556		}
11557	}
11558	out.Dispatch()
11559	if invalids > 0 {
11560		return graphql.Null
11561	}
11562	return out
11563}
11564
11565var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11566
11567func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11568	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11569
11570	out := graphql.NewFieldSet(fields)
11571	var invalids uint32
11572	for i, field := range fields {
11573		switch field.Name {
11574		case "__typename":
11575			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11576		case "id":
11577			field := field
11578			out.Concurrently(i, func() (res graphql.Marshaler) {
11579				defer func() {
11580					if r := recover(); r != nil {
11581						ec.Error(ctx, ec.Recover(ctx, r))
11582					}
11583				}()
11584				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11585				if res == graphql.Null {
11586					atomic.AddUint32(&invalids, 1)
11587				}
11588				return res
11589			})
11590		case "author":
11591			field := field
11592			out.Concurrently(i, func() (res graphql.Marshaler) {
11593				defer func() {
11594					if r := recover(); r != nil {
11595						ec.Error(ctx, ec.Recover(ctx, r))
11596					}
11597				}()
11598				res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
11599				if res == graphql.Null {
11600					atomic.AddUint32(&invalids, 1)
11601				}
11602				return res
11603			})
11604		case "date":
11605			field := field
11606			out.Concurrently(i, func() (res graphql.Marshaler) {
11607				defer func() {
11608					if r := recover(); r != nil {
11609						ec.Error(ctx, ec.Recover(ctx, r))
11610					}
11611				}()
11612				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
11613				if res == graphql.Null {
11614					atomic.AddUint32(&invalids, 1)
11615				}
11616				return res
11617			})
11618		case "added":
11619			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
11620			if out.Values[i] == graphql.Null {
11621				atomic.AddUint32(&invalids, 1)
11622			}
11623		case "removed":
11624			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
11625			if out.Values[i] == graphql.Null {
11626				atomic.AddUint32(&invalids, 1)
11627			}
11628		default:
11629			panic("unknown field " + strconv.Quote(field.Name))
11630		}
11631	}
11632	out.Dispatch()
11633	if invalids > 0 {
11634		return graphql.Null
11635	}
11636	return out
11637}
11638
11639var labelConnectionImplementors = []string{"LabelConnection"}
11640
11641func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
11642	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
11643
11644	out := graphql.NewFieldSet(fields)
11645	var invalids uint32
11646	for i, field := range fields {
11647		switch field.Name {
11648		case "__typename":
11649			out.Values[i] = graphql.MarshalString("LabelConnection")
11650		case "edges":
11651			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
11652			if out.Values[i] == graphql.Null {
11653				invalids++
11654			}
11655		case "nodes":
11656			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
11657			if out.Values[i] == graphql.Null {
11658				invalids++
11659			}
11660		case "pageInfo":
11661			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
11662			if out.Values[i] == graphql.Null {
11663				invalids++
11664			}
11665		case "totalCount":
11666			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
11667			if out.Values[i] == graphql.Null {
11668				invalids++
11669			}
11670		default:
11671			panic("unknown field " + strconv.Quote(field.Name))
11672		}
11673	}
11674	out.Dispatch()
11675	if invalids > 0 {
11676		return graphql.Null
11677	}
11678	return out
11679}
11680
11681var labelEdgeImplementors = []string{"LabelEdge"}
11682
11683func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
11684	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
11685
11686	out := graphql.NewFieldSet(fields)
11687	var invalids uint32
11688	for i, field := range fields {
11689		switch field.Name {
11690		case "__typename":
11691			out.Values[i] = graphql.MarshalString("LabelEdge")
11692		case "cursor":
11693			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
11694			if out.Values[i] == graphql.Null {
11695				invalids++
11696			}
11697		case "node":
11698			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
11699			if out.Values[i] == graphql.Null {
11700				invalids++
11701			}
11702		default:
11703			panic("unknown field " + strconv.Quote(field.Name))
11704		}
11705	}
11706	out.Dispatch()
11707	if invalids > 0 {
11708		return graphql.Null
11709	}
11710	return out
11711}
11712
11713var mutationImplementors = []string{"Mutation"}
11714
11715func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11716	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
11717
11718	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11719		Object: "Mutation",
11720	})
11721
11722	out := graphql.NewFieldSet(fields)
11723	var invalids uint32
11724	for i, field := range fields {
11725		switch field.Name {
11726		case "__typename":
11727			out.Values[i] = graphql.MarshalString("Mutation")
11728		case "newBug":
11729			out.Values[i] = ec._Mutation_newBug(ctx, field)
11730			if out.Values[i] == graphql.Null {
11731				invalids++
11732			}
11733		case "addComment":
11734			out.Values[i] = ec._Mutation_addComment(ctx, field)
11735			if out.Values[i] == graphql.Null {
11736				invalids++
11737			}
11738		case "changeLabels":
11739			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
11740			if out.Values[i] == graphql.Null {
11741				invalids++
11742			}
11743		case "openBug":
11744			out.Values[i] = ec._Mutation_openBug(ctx, field)
11745			if out.Values[i] == graphql.Null {
11746				invalids++
11747			}
11748		case "closeBug":
11749			out.Values[i] = ec._Mutation_closeBug(ctx, field)
11750			if out.Values[i] == graphql.Null {
11751				invalids++
11752			}
11753		case "setTitle":
11754			out.Values[i] = ec._Mutation_setTitle(ctx, field)
11755			if out.Values[i] == graphql.Null {
11756				invalids++
11757			}
11758		default:
11759			panic("unknown field " + strconv.Quote(field.Name))
11760		}
11761	}
11762	out.Dispatch()
11763	if invalids > 0 {
11764		return graphql.Null
11765	}
11766	return out
11767}
11768
11769var newBugPayloadImplementors = []string{"NewBugPayload"}
11770
11771func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
11772	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
11773
11774	out := graphql.NewFieldSet(fields)
11775	var invalids uint32
11776	for i, field := range fields {
11777		switch field.Name {
11778		case "__typename":
11779			out.Values[i] = graphql.MarshalString("NewBugPayload")
11780		case "clientMutationId":
11781			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
11782		case "bug":
11783			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
11784			if out.Values[i] == graphql.Null {
11785				invalids++
11786			}
11787		case "operation":
11788			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
11789			if out.Values[i] == graphql.Null {
11790				invalids++
11791			}
11792		default:
11793			panic("unknown field " + strconv.Quote(field.Name))
11794		}
11795	}
11796	out.Dispatch()
11797	if invalids > 0 {
11798		return graphql.Null
11799	}
11800	return out
11801}
11802
11803var openBugPayloadImplementors = []string{"OpenBugPayload"}
11804
11805func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
11806	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
11807
11808	out := graphql.NewFieldSet(fields)
11809	var invalids uint32
11810	for i, field := range fields {
11811		switch field.Name {
11812		case "__typename":
11813			out.Values[i] = graphql.MarshalString("OpenBugPayload")
11814		case "clientMutationId":
11815			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
11816		case "bug":
11817			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
11818			if out.Values[i] == graphql.Null {
11819				invalids++
11820			}
11821		case "operation":
11822			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
11823			if out.Values[i] == graphql.Null {
11824				invalids++
11825			}
11826		default:
11827			panic("unknown field " + strconv.Quote(field.Name))
11828		}
11829	}
11830	out.Dispatch()
11831	if invalids > 0 {
11832		return graphql.Null
11833	}
11834	return out
11835}
11836
11837var operationConnectionImplementors = []string{"OperationConnection"}
11838
11839func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
11840	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
11841
11842	out := graphql.NewFieldSet(fields)
11843	var invalids uint32
11844	for i, field := range fields {
11845		switch field.Name {
11846		case "__typename":
11847			out.Values[i] = graphql.MarshalString("OperationConnection")
11848		case "edges":
11849			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
11850			if out.Values[i] == graphql.Null {
11851				invalids++
11852			}
11853		case "nodes":
11854			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
11855			if out.Values[i] == graphql.Null {
11856				invalids++
11857			}
11858		case "pageInfo":
11859			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
11860			if out.Values[i] == graphql.Null {
11861				invalids++
11862			}
11863		case "totalCount":
11864			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
11865			if out.Values[i] == graphql.Null {
11866				invalids++
11867			}
11868		default:
11869			panic("unknown field " + strconv.Quote(field.Name))
11870		}
11871	}
11872	out.Dispatch()
11873	if invalids > 0 {
11874		return graphql.Null
11875	}
11876	return out
11877}
11878
11879var operationEdgeImplementors = []string{"OperationEdge"}
11880
11881func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
11882	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
11883
11884	out := graphql.NewFieldSet(fields)
11885	var invalids uint32
11886	for i, field := range fields {
11887		switch field.Name {
11888		case "__typename":
11889			out.Values[i] = graphql.MarshalString("OperationEdge")
11890		case "cursor":
11891			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
11892			if out.Values[i] == graphql.Null {
11893				invalids++
11894			}
11895		case "node":
11896			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
11897			if out.Values[i] == graphql.Null {
11898				invalids++
11899			}
11900		default:
11901			panic("unknown field " + strconv.Quote(field.Name))
11902		}
11903	}
11904	out.Dispatch()
11905	if invalids > 0 {
11906		return graphql.Null
11907	}
11908	return out
11909}
11910
11911var pageInfoImplementors = []string{"PageInfo"}
11912
11913func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
11914	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
11915
11916	out := graphql.NewFieldSet(fields)
11917	var invalids uint32
11918	for i, field := range fields {
11919		switch field.Name {
11920		case "__typename":
11921			out.Values[i] = graphql.MarshalString("PageInfo")
11922		case "hasNextPage":
11923			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
11924			if out.Values[i] == graphql.Null {
11925				invalids++
11926			}
11927		case "hasPreviousPage":
11928			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
11929			if out.Values[i] == graphql.Null {
11930				invalids++
11931			}
11932		case "startCursor":
11933			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
11934			if out.Values[i] == graphql.Null {
11935				invalids++
11936			}
11937		case "endCursor":
11938			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
11939			if out.Values[i] == graphql.Null {
11940				invalids++
11941			}
11942		default:
11943			panic("unknown field " + strconv.Quote(field.Name))
11944		}
11945	}
11946	out.Dispatch()
11947	if invalids > 0 {
11948		return graphql.Null
11949	}
11950	return out
11951}
11952
11953var queryImplementors = []string{"Query"}
11954
11955func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11956	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
11957
11958	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11959		Object: "Query",
11960	})
11961
11962	out := graphql.NewFieldSet(fields)
11963	var invalids uint32
11964	for i, field := range fields {
11965		switch field.Name {
11966		case "__typename":
11967			out.Values[i] = graphql.MarshalString("Query")
11968		case "repository":
11969			field := field
11970			out.Concurrently(i, func() (res graphql.Marshaler) {
11971				defer func() {
11972					if r := recover(); r != nil {
11973						ec.Error(ctx, ec.Recover(ctx, r))
11974					}
11975				}()
11976				res = ec._Query_repository(ctx, field)
11977				return res
11978			})
11979		case "__type":
11980			out.Values[i] = ec._Query___type(ctx, field)
11981		case "__schema":
11982			out.Values[i] = ec._Query___schema(ctx, field)
11983		default:
11984			panic("unknown field " + strconv.Quote(field.Name))
11985		}
11986	}
11987	out.Dispatch()
11988	if invalids > 0 {
11989		return graphql.Null
11990	}
11991	return out
11992}
11993
11994var repositoryImplementors = []string{"Repository"}
11995
11996func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
11997	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
11998
11999	out := graphql.NewFieldSet(fields)
12000	var invalids uint32
12001	for i, field := range fields {
12002		switch field.Name {
12003		case "__typename":
12004			out.Values[i] = graphql.MarshalString("Repository")
12005		case "name":
12006			field := field
12007			out.Concurrently(i, func() (res graphql.Marshaler) {
12008				defer func() {
12009					if r := recover(); r != nil {
12010						ec.Error(ctx, ec.Recover(ctx, r))
12011					}
12012				}()
12013				res = ec._Repository_name(ctx, field, obj)
12014				return res
12015			})
12016		case "allBugs":
12017			field := field
12018			out.Concurrently(i, func() (res graphql.Marshaler) {
12019				defer func() {
12020					if r := recover(); r != nil {
12021						ec.Error(ctx, ec.Recover(ctx, r))
12022					}
12023				}()
12024				res = ec._Repository_allBugs(ctx, field, obj)
12025				if res == graphql.Null {
12026					atomic.AddUint32(&invalids, 1)
12027				}
12028				return res
12029			})
12030		case "bug":
12031			field := field
12032			out.Concurrently(i, func() (res graphql.Marshaler) {
12033				defer func() {
12034					if r := recover(); r != nil {
12035						ec.Error(ctx, ec.Recover(ctx, r))
12036					}
12037				}()
12038				res = ec._Repository_bug(ctx, field, obj)
12039				return res
12040			})
12041		case "allIdentities":
12042			field := field
12043			out.Concurrently(i, func() (res graphql.Marshaler) {
12044				defer func() {
12045					if r := recover(); r != nil {
12046						ec.Error(ctx, ec.Recover(ctx, r))
12047					}
12048				}()
12049				res = ec._Repository_allIdentities(ctx, field, obj)
12050				if res == graphql.Null {
12051					atomic.AddUint32(&invalids, 1)
12052				}
12053				return res
12054			})
12055		case "identity":
12056			field := field
12057			out.Concurrently(i, func() (res graphql.Marshaler) {
12058				defer func() {
12059					if r := recover(); r != nil {
12060						ec.Error(ctx, ec.Recover(ctx, r))
12061					}
12062				}()
12063				res = ec._Repository_identity(ctx, field, obj)
12064				return res
12065			})
12066		case "userIdentity":
12067			field := field
12068			out.Concurrently(i, func() (res graphql.Marshaler) {
12069				defer func() {
12070					if r := recover(); r != nil {
12071						ec.Error(ctx, ec.Recover(ctx, r))
12072					}
12073				}()
12074				res = ec._Repository_userIdentity(ctx, field, obj)
12075				return res
12076			})
12077		case "validLabels":
12078			field := field
12079			out.Concurrently(i, func() (res graphql.Marshaler) {
12080				defer func() {
12081					if r := recover(); r != nil {
12082						ec.Error(ctx, ec.Recover(ctx, r))
12083					}
12084				}()
12085				res = ec._Repository_validLabels(ctx, field, obj)
12086				if res == graphql.Null {
12087					atomic.AddUint32(&invalids, 1)
12088				}
12089				return res
12090			})
12091		default:
12092			panic("unknown field " + strconv.Quote(field.Name))
12093		}
12094	}
12095	out.Dispatch()
12096	if invalids > 0 {
12097		return graphql.Null
12098	}
12099	return out
12100}
12101
12102var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12103
12104func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12105	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12106
12107	out := graphql.NewFieldSet(fields)
12108	var invalids uint32
12109	for i, field := range fields {
12110		switch field.Name {
12111		case "__typename":
12112			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12113		case "id":
12114			field := field
12115			out.Concurrently(i, func() (res graphql.Marshaler) {
12116				defer func() {
12117					if r := recover(); r != nil {
12118						ec.Error(ctx, ec.Recover(ctx, r))
12119					}
12120				}()
12121				res = ec._SetStatusOperation_id(ctx, field, obj)
12122				if res == graphql.Null {
12123					atomic.AddUint32(&invalids, 1)
12124				}
12125				return res
12126			})
12127		case "author":
12128			field := field
12129			out.Concurrently(i, func() (res graphql.Marshaler) {
12130				defer func() {
12131					if r := recover(); r != nil {
12132						ec.Error(ctx, ec.Recover(ctx, r))
12133					}
12134				}()
12135				res = ec._SetStatusOperation_author(ctx, field, obj)
12136				if res == graphql.Null {
12137					atomic.AddUint32(&invalids, 1)
12138				}
12139				return res
12140			})
12141		case "date":
12142			field := field
12143			out.Concurrently(i, func() (res graphql.Marshaler) {
12144				defer func() {
12145					if r := recover(); r != nil {
12146						ec.Error(ctx, ec.Recover(ctx, r))
12147					}
12148				}()
12149				res = ec._SetStatusOperation_date(ctx, field, obj)
12150				if res == graphql.Null {
12151					atomic.AddUint32(&invalids, 1)
12152				}
12153				return res
12154			})
12155		case "status":
12156			field := field
12157			out.Concurrently(i, func() (res graphql.Marshaler) {
12158				defer func() {
12159					if r := recover(); r != nil {
12160						ec.Error(ctx, ec.Recover(ctx, r))
12161					}
12162				}()
12163				res = ec._SetStatusOperation_status(ctx, field, obj)
12164				if res == graphql.Null {
12165					atomic.AddUint32(&invalids, 1)
12166				}
12167				return res
12168			})
12169		default:
12170			panic("unknown field " + strconv.Quote(field.Name))
12171		}
12172	}
12173	out.Dispatch()
12174	if invalids > 0 {
12175		return graphql.Null
12176	}
12177	return out
12178}
12179
12180var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12181
12182func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12183	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12184
12185	out := graphql.NewFieldSet(fields)
12186	var invalids uint32
12187	for i, field := range fields {
12188		switch field.Name {
12189		case "__typename":
12190			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12191		case "id":
12192			field := field
12193			out.Concurrently(i, func() (res graphql.Marshaler) {
12194				defer func() {
12195					if r := recover(); r != nil {
12196						ec.Error(ctx, ec.Recover(ctx, r))
12197					}
12198				}()
12199				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12200				if res == graphql.Null {
12201					atomic.AddUint32(&invalids, 1)
12202				}
12203				return res
12204			})
12205		case "author":
12206			field := field
12207			out.Concurrently(i, func() (res graphql.Marshaler) {
12208				defer func() {
12209					if r := recover(); r != nil {
12210						ec.Error(ctx, ec.Recover(ctx, r))
12211					}
12212				}()
12213				res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12214				if res == graphql.Null {
12215					atomic.AddUint32(&invalids, 1)
12216				}
12217				return res
12218			})
12219		case "date":
12220			field := field
12221			out.Concurrently(i, func() (res graphql.Marshaler) {
12222				defer func() {
12223					if r := recover(); r != nil {
12224						ec.Error(ctx, ec.Recover(ctx, r))
12225					}
12226				}()
12227				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12228				if res == graphql.Null {
12229					atomic.AddUint32(&invalids, 1)
12230				}
12231				return res
12232			})
12233		case "status":
12234			field := field
12235			out.Concurrently(i, func() (res graphql.Marshaler) {
12236				defer func() {
12237					if r := recover(); r != nil {
12238						ec.Error(ctx, ec.Recover(ctx, r))
12239					}
12240				}()
12241				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12242				if res == graphql.Null {
12243					atomic.AddUint32(&invalids, 1)
12244				}
12245				return res
12246			})
12247		default:
12248			panic("unknown field " + strconv.Quote(field.Name))
12249		}
12250	}
12251	out.Dispatch()
12252	if invalids > 0 {
12253		return graphql.Null
12254	}
12255	return out
12256}
12257
12258var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12259
12260func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12261	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12262
12263	out := graphql.NewFieldSet(fields)
12264	var invalids uint32
12265	for i, field := range fields {
12266		switch field.Name {
12267		case "__typename":
12268			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12269		case "id":
12270			field := field
12271			out.Concurrently(i, func() (res graphql.Marshaler) {
12272				defer func() {
12273					if r := recover(); r != nil {
12274						ec.Error(ctx, ec.Recover(ctx, r))
12275					}
12276				}()
12277				res = ec._SetTitleOperation_id(ctx, field, obj)
12278				if res == graphql.Null {
12279					atomic.AddUint32(&invalids, 1)
12280				}
12281				return res
12282			})
12283		case "author":
12284			field := field
12285			out.Concurrently(i, func() (res graphql.Marshaler) {
12286				defer func() {
12287					if r := recover(); r != nil {
12288						ec.Error(ctx, ec.Recover(ctx, r))
12289					}
12290				}()
12291				res = ec._SetTitleOperation_author(ctx, field, obj)
12292				if res == graphql.Null {
12293					atomic.AddUint32(&invalids, 1)
12294				}
12295				return res
12296			})
12297		case "date":
12298			field := field
12299			out.Concurrently(i, func() (res graphql.Marshaler) {
12300				defer func() {
12301					if r := recover(); r != nil {
12302						ec.Error(ctx, ec.Recover(ctx, r))
12303					}
12304				}()
12305				res = ec._SetTitleOperation_date(ctx, field, obj)
12306				if res == graphql.Null {
12307					atomic.AddUint32(&invalids, 1)
12308				}
12309				return res
12310			})
12311		case "title":
12312			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12313			if out.Values[i] == graphql.Null {
12314				atomic.AddUint32(&invalids, 1)
12315			}
12316		case "was":
12317			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12318			if out.Values[i] == graphql.Null {
12319				atomic.AddUint32(&invalids, 1)
12320			}
12321		default:
12322			panic("unknown field " + strconv.Quote(field.Name))
12323		}
12324	}
12325	out.Dispatch()
12326	if invalids > 0 {
12327		return graphql.Null
12328	}
12329	return out
12330}
12331
12332var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12333
12334func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12335	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12336
12337	out := graphql.NewFieldSet(fields)
12338	var invalids uint32
12339	for i, field := range fields {
12340		switch field.Name {
12341		case "__typename":
12342			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12343		case "clientMutationId":
12344			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12345		case "bug":
12346			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12347			if out.Values[i] == graphql.Null {
12348				invalids++
12349			}
12350		case "operation":
12351			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12352			if out.Values[i] == graphql.Null {
12353				invalids++
12354			}
12355		default:
12356			panic("unknown field " + strconv.Quote(field.Name))
12357		}
12358	}
12359	out.Dispatch()
12360	if invalids > 0 {
12361		return graphql.Null
12362	}
12363	return out
12364}
12365
12366var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12367
12368func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12369	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12370
12371	out := graphql.NewFieldSet(fields)
12372	var invalids uint32
12373	for i, field := range fields {
12374		switch field.Name {
12375		case "__typename":
12376			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12377		case "id":
12378			field := field
12379			out.Concurrently(i, func() (res graphql.Marshaler) {
12380				defer func() {
12381					if r := recover(); r != nil {
12382						ec.Error(ctx, ec.Recover(ctx, r))
12383					}
12384				}()
12385				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12386				if res == graphql.Null {
12387					atomic.AddUint32(&invalids, 1)
12388				}
12389				return res
12390			})
12391		case "author":
12392			field := field
12393			out.Concurrently(i, func() (res graphql.Marshaler) {
12394				defer func() {
12395					if r := recover(); r != nil {
12396						ec.Error(ctx, ec.Recover(ctx, r))
12397					}
12398				}()
12399				res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12400				if res == graphql.Null {
12401					atomic.AddUint32(&invalids, 1)
12402				}
12403				return res
12404			})
12405		case "date":
12406			field := field
12407			out.Concurrently(i, func() (res graphql.Marshaler) {
12408				defer func() {
12409					if r := recover(); r != nil {
12410						ec.Error(ctx, ec.Recover(ctx, r))
12411					}
12412				}()
12413				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12414				if res == graphql.Null {
12415					atomic.AddUint32(&invalids, 1)
12416				}
12417				return res
12418			})
12419		case "title":
12420			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12421			if out.Values[i] == graphql.Null {
12422				atomic.AddUint32(&invalids, 1)
12423			}
12424		case "was":
12425			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12426			if out.Values[i] == graphql.Null {
12427				atomic.AddUint32(&invalids, 1)
12428			}
12429		default:
12430			panic("unknown field " + strconv.Quote(field.Name))
12431		}
12432	}
12433	out.Dispatch()
12434	if invalids > 0 {
12435		return graphql.Null
12436	}
12437	return out
12438}
12439
12440var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12441
12442func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12443	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12444
12445	out := graphql.NewFieldSet(fields)
12446	var invalids uint32
12447	for i, field := range fields {
12448		switch field.Name {
12449		case "__typename":
12450			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12451		case "edges":
12452			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12453			if out.Values[i] == graphql.Null {
12454				invalids++
12455			}
12456		case "nodes":
12457			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12458			if out.Values[i] == graphql.Null {
12459				invalids++
12460			}
12461		case "pageInfo":
12462			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12463			if out.Values[i] == graphql.Null {
12464				invalids++
12465			}
12466		case "totalCount":
12467			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12468			if out.Values[i] == graphql.Null {
12469				invalids++
12470			}
12471		default:
12472			panic("unknown field " + strconv.Quote(field.Name))
12473		}
12474	}
12475	out.Dispatch()
12476	if invalids > 0 {
12477		return graphql.Null
12478	}
12479	return out
12480}
12481
12482var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12483
12484func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12485	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12486
12487	out := graphql.NewFieldSet(fields)
12488	var invalids uint32
12489	for i, field := range fields {
12490		switch field.Name {
12491		case "__typename":
12492			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12493		case "cursor":
12494			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12495			if out.Values[i] == graphql.Null {
12496				invalids++
12497			}
12498		case "node":
12499			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12500			if out.Values[i] == graphql.Null {
12501				invalids++
12502			}
12503		default:
12504			panic("unknown field " + strconv.Quote(field.Name))
12505		}
12506	}
12507	out.Dispatch()
12508	if invalids > 0 {
12509		return graphql.Null
12510	}
12511	return out
12512}
12513
12514var __DirectiveImplementors = []string{"__Directive"}
12515
12516func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12517	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12518
12519	out := graphql.NewFieldSet(fields)
12520	var invalids uint32
12521	for i, field := range fields {
12522		switch field.Name {
12523		case "__typename":
12524			out.Values[i] = graphql.MarshalString("__Directive")
12525		case "name":
12526			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12527			if out.Values[i] == graphql.Null {
12528				invalids++
12529			}
12530		case "description":
12531			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12532		case "locations":
12533			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12534			if out.Values[i] == graphql.Null {
12535				invalids++
12536			}
12537		case "args":
12538			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12539			if out.Values[i] == graphql.Null {
12540				invalids++
12541			}
12542		default:
12543			panic("unknown field " + strconv.Quote(field.Name))
12544		}
12545	}
12546	out.Dispatch()
12547	if invalids > 0 {
12548		return graphql.Null
12549	}
12550	return out
12551}
12552
12553var __EnumValueImplementors = []string{"__EnumValue"}
12554
12555func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12556	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12557
12558	out := graphql.NewFieldSet(fields)
12559	var invalids uint32
12560	for i, field := range fields {
12561		switch field.Name {
12562		case "__typename":
12563			out.Values[i] = graphql.MarshalString("__EnumValue")
12564		case "name":
12565			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12566			if out.Values[i] == graphql.Null {
12567				invalids++
12568			}
12569		case "description":
12570			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12571		case "isDeprecated":
12572			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12573			if out.Values[i] == graphql.Null {
12574				invalids++
12575			}
12576		case "deprecationReason":
12577			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12578		default:
12579			panic("unknown field " + strconv.Quote(field.Name))
12580		}
12581	}
12582	out.Dispatch()
12583	if invalids > 0 {
12584		return graphql.Null
12585	}
12586	return out
12587}
12588
12589var __FieldImplementors = []string{"__Field"}
12590
12591func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12592	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
12593
12594	out := graphql.NewFieldSet(fields)
12595	var invalids uint32
12596	for i, field := range fields {
12597		switch field.Name {
12598		case "__typename":
12599			out.Values[i] = graphql.MarshalString("__Field")
12600		case "name":
12601			out.Values[i] = ec.___Field_name(ctx, field, obj)
12602			if out.Values[i] == graphql.Null {
12603				invalids++
12604			}
12605		case "description":
12606			out.Values[i] = ec.___Field_description(ctx, field, obj)
12607		case "args":
12608			out.Values[i] = ec.___Field_args(ctx, field, obj)
12609			if out.Values[i] == graphql.Null {
12610				invalids++
12611			}
12612		case "type":
12613			out.Values[i] = ec.___Field_type(ctx, field, obj)
12614			if out.Values[i] == graphql.Null {
12615				invalids++
12616			}
12617		case "isDeprecated":
12618			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
12619			if out.Values[i] == graphql.Null {
12620				invalids++
12621			}
12622		case "deprecationReason":
12623			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
12624		default:
12625			panic("unknown field " + strconv.Quote(field.Name))
12626		}
12627	}
12628	out.Dispatch()
12629	if invalids > 0 {
12630		return graphql.Null
12631	}
12632	return out
12633}
12634
12635var __InputValueImplementors = []string{"__InputValue"}
12636
12637func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
12638	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
12639
12640	out := graphql.NewFieldSet(fields)
12641	var invalids uint32
12642	for i, field := range fields {
12643		switch field.Name {
12644		case "__typename":
12645			out.Values[i] = graphql.MarshalString("__InputValue")
12646		case "name":
12647			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
12648			if out.Values[i] == graphql.Null {
12649				invalids++
12650			}
12651		case "description":
12652			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
12653		case "type":
12654			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
12655			if out.Values[i] == graphql.Null {
12656				invalids++
12657			}
12658		case "defaultValue":
12659			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
12660		default:
12661			panic("unknown field " + strconv.Quote(field.Name))
12662		}
12663	}
12664	out.Dispatch()
12665	if invalids > 0 {
12666		return graphql.Null
12667	}
12668	return out
12669}
12670
12671var __SchemaImplementors = []string{"__Schema"}
12672
12673func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
12674	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
12675
12676	out := graphql.NewFieldSet(fields)
12677	var invalids uint32
12678	for i, field := range fields {
12679		switch field.Name {
12680		case "__typename":
12681			out.Values[i] = graphql.MarshalString("__Schema")
12682		case "types":
12683			out.Values[i] = ec.___Schema_types(ctx, field, obj)
12684			if out.Values[i] == graphql.Null {
12685				invalids++
12686			}
12687		case "queryType":
12688			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
12689			if out.Values[i] == graphql.Null {
12690				invalids++
12691			}
12692		case "mutationType":
12693			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
12694		case "subscriptionType":
12695			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
12696		case "directives":
12697			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
12698			if out.Values[i] == graphql.Null {
12699				invalids++
12700			}
12701		default:
12702			panic("unknown field " + strconv.Quote(field.Name))
12703		}
12704	}
12705	out.Dispatch()
12706	if invalids > 0 {
12707		return graphql.Null
12708	}
12709	return out
12710}
12711
12712var __TypeImplementors = []string{"__Type"}
12713
12714func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
12715	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
12716
12717	out := graphql.NewFieldSet(fields)
12718	var invalids uint32
12719	for i, field := range fields {
12720		switch field.Name {
12721		case "__typename":
12722			out.Values[i] = graphql.MarshalString("__Type")
12723		case "kind":
12724			out.Values[i] = ec.___Type_kind(ctx, field, obj)
12725			if out.Values[i] == graphql.Null {
12726				invalids++
12727			}
12728		case "name":
12729			out.Values[i] = ec.___Type_name(ctx, field, obj)
12730		case "description":
12731			out.Values[i] = ec.___Type_description(ctx, field, obj)
12732		case "fields":
12733			out.Values[i] = ec.___Type_fields(ctx, field, obj)
12734		case "interfaces":
12735			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
12736		case "possibleTypes":
12737			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
12738		case "enumValues":
12739			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
12740		case "inputFields":
12741			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
12742		case "ofType":
12743			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
12744		default:
12745			panic("unknown field " + strconv.Quote(field.Name))
12746		}
12747	}
12748	out.Dispatch()
12749	if invalids > 0 {
12750		return graphql.Null
12751	}
12752	return out
12753}
12754
12755// endregion **************************** object.gotpl ****************************
12756
12757// region    ***************************** type.gotpl *****************************
12758
12759func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
12760	return ec.unmarshalInputAddCommentInput(ctx, v)
12761}
12762
12763func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
12764	return ec._AddCommentOperation(ctx, sel, &v)
12765}
12766
12767func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
12768	if v == nil {
12769		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12770			ec.Errorf(ctx, "must not be null")
12771		}
12772		return graphql.Null
12773	}
12774	return ec._AddCommentOperation(ctx, sel, v)
12775}
12776
12777func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
12778	return ec._AddCommentPayload(ctx, sel, &v)
12779}
12780
12781func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
12782	if v == nil {
12783		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12784			ec.Errorf(ctx, "must not be null")
12785		}
12786		return graphql.Null
12787	}
12788	return ec._AddCommentPayload(ctx, sel, v)
12789}
12790
12791func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
12792	return graphql.UnmarshalBoolean(v)
12793}
12794
12795func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
12796	res := graphql.MarshalBoolean(v)
12797	if res == graphql.Null {
12798		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12799			ec.Errorf(ctx, "must not be null")
12800		}
12801	}
12802	return res
12803}
12804
12805func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
12806	if v == nil {
12807		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12808			ec.Errorf(ctx, "must not be null")
12809		}
12810		return graphql.Null
12811	}
12812	return ec._Bug(ctx, sel, v)
12813}
12814
12815func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
12816	ret := make(graphql.Array, len(v))
12817	var wg sync.WaitGroup
12818	isLen1 := len(v) == 1
12819	if !isLen1 {
12820		wg.Add(len(v))
12821	}
12822	for i := range v {
12823		i := i
12824		fc := &graphql.FieldContext{
12825			Index:  &i,
12826			Result: &v[i],
12827		}
12828		ctx := graphql.WithFieldContext(ctx, fc)
12829		f := func(i int) {
12830			defer func() {
12831				if r := recover(); r != nil {
12832					ec.Error(ctx, ec.Recover(ctx, r))
12833					ret = nil
12834				}
12835			}()
12836			if !isLen1 {
12837				defer wg.Done()
12838			}
12839			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
12840		}
12841		if isLen1 {
12842			f(i)
12843		} else {
12844			go f(i)
12845		}
12846
12847	}
12848	wg.Wait()
12849	return ret
12850}
12851
12852func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
12853	return ec._BugConnection(ctx, sel, &v)
12854}
12855
12856func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
12857	if v == nil {
12858		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12859			ec.Errorf(ctx, "must not be null")
12860		}
12861		return graphql.Null
12862	}
12863	return ec._BugConnection(ctx, sel, v)
12864}
12865
12866func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
12867	return ec._BugEdge(ctx, sel, &v)
12868}
12869
12870func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
12871	ret := make(graphql.Array, len(v))
12872	var wg sync.WaitGroup
12873	isLen1 := len(v) == 1
12874	if !isLen1 {
12875		wg.Add(len(v))
12876	}
12877	for i := range v {
12878		i := i
12879		fc := &graphql.FieldContext{
12880			Index:  &i,
12881			Result: &v[i],
12882		}
12883		ctx := graphql.WithFieldContext(ctx, fc)
12884		f := func(i int) {
12885			defer func() {
12886				if r := recover(); r != nil {
12887					ec.Error(ctx, ec.Recover(ctx, r))
12888					ret = nil
12889				}
12890			}()
12891			if !isLen1 {
12892				defer wg.Done()
12893			}
12894			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
12895		}
12896		if isLen1 {
12897			f(i)
12898		} else {
12899			go f(i)
12900		}
12901
12902	}
12903	wg.Wait()
12904	return ret
12905}
12906
12907func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
12908	if v == nil {
12909		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12910			ec.Errorf(ctx, "must not be null")
12911		}
12912		return graphql.Null
12913	}
12914	return ec._BugEdge(ctx, sel, v)
12915}
12916
12917func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
12918	return ec._ChangeLabelPayload(ctx, sel, &v)
12919}
12920
12921func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
12922	if v == nil {
12923		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12924			ec.Errorf(ctx, "must not be null")
12925		}
12926		return graphql.Null
12927	}
12928	return ec._ChangeLabelPayload(ctx, sel, v)
12929}
12930
12931func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
12932	return ec.unmarshalInputCloseBugInput(ctx, v)
12933}
12934
12935func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
12936	return ec._CloseBugPayload(ctx, sel, &v)
12937}
12938
12939func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
12940	if v == nil {
12941		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12942			ec.Errorf(ctx, "must not be null")
12943		}
12944		return graphql.Null
12945	}
12946	return ec._CloseBugPayload(ctx, sel, v)
12947}
12948
12949func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
12950	return ec._Color(ctx, sel, &v)
12951}
12952
12953func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
12954	if v == nil {
12955		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12956			ec.Errorf(ctx, "must not be null")
12957		}
12958		return graphql.Null
12959	}
12960	return ec._Color(ctx, sel, v)
12961}
12962
12963func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
12964	return ec._Comment(ctx, sel, &v)
12965}
12966
12967func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
12968	ret := make(graphql.Array, len(v))
12969	var wg sync.WaitGroup
12970	isLen1 := len(v) == 1
12971	if !isLen1 {
12972		wg.Add(len(v))
12973	}
12974	for i := range v {
12975		i := i
12976		fc := &graphql.FieldContext{
12977			Index:  &i,
12978			Result: &v[i],
12979		}
12980		ctx := graphql.WithFieldContext(ctx, fc)
12981		f := func(i int) {
12982			defer func() {
12983				if r := recover(); r != nil {
12984					ec.Error(ctx, ec.Recover(ctx, r))
12985					ret = nil
12986				}
12987			}()
12988			if !isLen1 {
12989				defer wg.Done()
12990			}
12991			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
12992		}
12993		if isLen1 {
12994			f(i)
12995		} else {
12996			go f(i)
12997		}
12998
12999	}
13000	wg.Wait()
13001	return ret
13002}
13003
13004func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13005	if v == nil {
13006		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13007			ec.Errorf(ctx, "must not be null")
13008		}
13009		return graphql.Null
13010	}
13011	return ec._Comment(ctx, sel, v)
13012}
13013
13014func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13015	return ec._CommentConnection(ctx, sel, &v)
13016}
13017
13018func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13019	if v == nil {
13020		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13021			ec.Errorf(ctx, "must not be null")
13022		}
13023		return graphql.Null
13024	}
13025	return ec._CommentConnection(ctx, sel, v)
13026}
13027
13028func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13029	return ec._CommentEdge(ctx, sel, &v)
13030}
13031
13032func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13033	ret := make(graphql.Array, len(v))
13034	var wg sync.WaitGroup
13035	isLen1 := len(v) == 1
13036	if !isLen1 {
13037		wg.Add(len(v))
13038	}
13039	for i := range v {
13040		i := i
13041		fc := &graphql.FieldContext{
13042			Index:  &i,
13043			Result: &v[i],
13044		}
13045		ctx := graphql.WithFieldContext(ctx, fc)
13046		f := func(i int) {
13047			defer func() {
13048				if r := recover(); r != nil {
13049					ec.Error(ctx, ec.Recover(ctx, r))
13050					ret = nil
13051				}
13052			}()
13053			if !isLen1 {
13054				defer wg.Done()
13055			}
13056			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13057		}
13058		if isLen1 {
13059			f(i)
13060		} else {
13061			go f(i)
13062		}
13063
13064	}
13065	wg.Wait()
13066	return ret
13067}
13068
13069func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13070	if v == nil {
13071		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13072			ec.Errorf(ctx, "must not be null")
13073		}
13074		return graphql.Null
13075	}
13076	return ec._CommentEdge(ctx, sel, v)
13077}
13078
13079func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13080	return ec._CommentHistoryStep(ctx, sel, &v)
13081}
13082
13083func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13084	ret := make(graphql.Array, len(v))
13085	var wg sync.WaitGroup
13086	isLen1 := len(v) == 1
13087	if !isLen1 {
13088		wg.Add(len(v))
13089	}
13090	for i := range v {
13091		i := i
13092		fc := &graphql.FieldContext{
13093			Index:  &i,
13094			Result: &v[i],
13095		}
13096		ctx := graphql.WithFieldContext(ctx, fc)
13097		f := func(i int) {
13098			defer func() {
13099				if r := recover(); r != nil {
13100					ec.Error(ctx, ec.Recover(ctx, r))
13101					ret = nil
13102				}
13103			}()
13104			if !isLen1 {
13105				defer wg.Done()
13106			}
13107			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13108		}
13109		if isLen1 {
13110			f(i)
13111		} else {
13112			go f(i)
13113		}
13114
13115	}
13116	wg.Wait()
13117	return ret
13118}
13119
13120func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13121	return ec._CreateOperation(ctx, sel, &v)
13122}
13123
13124func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13125	if v == nil {
13126		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13127			ec.Errorf(ctx, "must not be null")
13128		}
13129		return graphql.Null
13130	}
13131	return ec._CreateOperation(ctx, sel, v)
13132}
13133
13134func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13135	var res git.Hash
13136	return res, res.UnmarshalGQL(v)
13137}
13138
13139func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13140	return v
13141}
13142
13143func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13144	var vSlice []interface{}
13145	if v != nil {
13146		if tmp1, ok := v.([]interface{}); ok {
13147			vSlice = tmp1
13148		} else {
13149			vSlice = []interface{}{v}
13150		}
13151	}
13152	var err error
13153	res := make([]git.Hash, len(vSlice))
13154	for i := range vSlice {
13155		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13156		if err != nil {
13157			return nil, err
13158		}
13159	}
13160	return res, nil
13161}
13162
13163func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13164	ret := make(graphql.Array, len(v))
13165	for i := range v {
13166		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13167	}
13168
13169	return ret
13170}
13171
13172func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13173	if v == nil {
13174		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13175			ec.Errorf(ctx, "must not be null")
13176		}
13177		return graphql.Null
13178	}
13179	return ec._Identity(ctx, sel, v)
13180}
13181
13182func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13183	ret := make(graphql.Array, len(v))
13184	var wg sync.WaitGroup
13185	isLen1 := len(v) == 1
13186	if !isLen1 {
13187		wg.Add(len(v))
13188	}
13189	for i := range v {
13190		i := i
13191		fc := &graphql.FieldContext{
13192			Index:  &i,
13193			Result: &v[i],
13194		}
13195		ctx := graphql.WithFieldContext(ctx, fc)
13196		f := func(i int) {
13197			defer func() {
13198				if r := recover(); r != nil {
13199					ec.Error(ctx, ec.Recover(ctx, r))
13200					ret = nil
13201				}
13202			}()
13203			if !isLen1 {
13204				defer wg.Done()
13205			}
13206			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13207		}
13208		if isLen1 {
13209			f(i)
13210		} else {
13211			go f(i)
13212		}
13213
13214	}
13215	wg.Wait()
13216	return ret
13217}
13218
13219func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13220	return ec._IdentityConnection(ctx, sel, &v)
13221}
13222
13223func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13224	if v == nil {
13225		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13226			ec.Errorf(ctx, "must not be null")
13227		}
13228		return graphql.Null
13229	}
13230	return ec._IdentityConnection(ctx, sel, v)
13231}
13232
13233func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13234	return ec._IdentityEdge(ctx, sel, &v)
13235}
13236
13237func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13238	ret := make(graphql.Array, len(v))
13239	var wg sync.WaitGroup
13240	isLen1 := len(v) == 1
13241	if !isLen1 {
13242		wg.Add(len(v))
13243	}
13244	for i := range v {
13245		i := i
13246		fc := &graphql.FieldContext{
13247			Index:  &i,
13248			Result: &v[i],
13249		}
13250		ctx := graphql.WithFieldContext(ctx, fc)
13251		f := func(i int) {
13252			defer func() {
13253				if r := recover(); r != nil {
13254					ec.Error(ctx, ec.Recover(ctx, r))
13255					ret = nil
13256				}
13257			}()
13258			if !isLen1 {
13259				defer wg.Done()
13260			}
13261			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13262		}
13263		if isLen1 {
13264			f(i)
13265		} else {
13266			go f(i)
13267		}
13268
13269	}
13270	wg.Wait()
13271	return ret
13272}
13273
13274func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13275	if v == nil {
13276		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13277			ec.Errorf(ctx, "must not be null")
13278		}
13279		return graphql.Null
13280	}
13281	return ec._IdentityEdge(ctx, sel, v)
13282}
13283
13284func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13285	return graphql.UnmarshalInt(v)
13286}
13287
13288func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13289	res := graphql.MarshalInt(v)
13290	if res == graphql.Null {
13291		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13292			ec.Errorf(ctx, "must not be null")
13293		}
13294	}
13295	return res
13296}
13297
13298func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13299	return ec._Label(ctx, sel, &v)
13300}
13301
13302func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13303	ret := make(graphql.Array, len(v))
13304	var wg sync.WaitGroup
13305	isLen1 := len(v) == 1
13306	if !isLen1 {
13307		wg.Add(len(v))
13308	}
13309	for i := range v {
13310		i := i
13311		fc := &graphql.FieldContext{
13312			Index:  &i,
13313			Result: &v[i],
13314		}
13315		ctx := graphql.WithFieldContext(ctx, fc)
13316		f := func(i int) {
13317			defer func() {
13318				if r := recover(); r != nil {
13319					ec.Error(ctx, ec.Recover(ctx, r))
13320					ret = nil
13321				}
13322			}()
13323			if !isLen1 {
13324				defer wg.Done()
13325			}
13326			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13327		}
13328		if isLen1 {
13329			f(i)
13330		} else {
13331			go f(i)
13332		}
13333
13334	}
13335	wg.Wait()
13336	return ret
13337}
13338
13339func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13340	return ec._LabelChangeOperation(ctx, sel, &v)
13341}
13342
13343func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13344	if v == nil {
13345		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13346			ec.Errorf(ctx, "must not be null")
13347		}
13348		return graphql.Null
13349	}
13350	return ec._LabelChangeOperation(ctx, sel, v)
13351}
13352
13353func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13354	ret := make(graphql.Array, len(v))
13355	var wg sync.WaitGroup
13356	isLen1 := len(v) == 1
13357	if !isLen1 {
13358		wg.Add(len(v))
13359	}
13360	for i := range v {
13361		i := i
13362		fc := &graphql.FieldContext{
13363			Index:  &i,
13364			Result: &v[i],
13365		}
13366		ctx := graphql.WithFieldContext(ctx, fc)
13367		f := func(i int) {
13368			defer func() {
13369				if r := recover(); r != nil {
13370					ec.Error(ctx, ec.Recover(ctx, r))
13371					ret = nil
13372				}
13373			}()
13374			if !isLen1 {
13375				defer wg.Done()
13376			}
13377			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13378		}
13379		if isLen1 {
13380			f(i)
13381		} else {
13382			go f(i)
13383		}
13384
13385	}
13386	wg.Wait()
13387	return ret
13388}
13389
13390func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13391	var res models.LabelChangeStatus
13392	return res, res.UnmarshalGQL(v)
13393}
13394
13395func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13396	return v
13397}
13398
13399func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13400	return ec._LabelConnection(ctx, sel, &v)
13401}
13402
13403func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13404	if v == nil {
13405		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13406			ec.Errorf(ctx, "must not be null")
13407		}
13408		return graphql.Null
13409	}
13410	return ec._LabelConnection(ctx, sel, v)
13411}
13412
13413func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13414	return ec._LabelEdge(ctx, sel, &v)
13415}
13416
13417func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13418	ret := make(graphql.Array, len(v))
13419	var wg sync.WaitGroup
13420	isLen1 := len(v) == 1
13421	if !isLen1 {
13422		wg.Add(len(v))
13423	}
13424	for i := range v {
13425		i := i
13426		fc := &graphql.FieldContext{
13427			Index:  &i,
13428			Result: &v[i],
13429		}
13430		ctx := graphql.WithFieldContext(ctx, fc)
13431		f := func(i int) {
13432			defer func() {
13433				if r := recover(); r != nil {
13434					ec.Error(ctx, ec.Recover(ctx, r))
13435					ret = nil
13436				}
13437			}()
13438			if !isLen1 {
13439				defer wg.Done()
13440			}
13441			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13442		}
13443		if isLen1 {
13444			f(i)
13445		} else {
13446			go f(i)
13447		}
13448
13449	}
13450	wg.Wait()
13451	return ret
13452}
13453
13454func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13455	if v == nil {
13456		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13457			ec.Errorf(ctx, "must not be null")
13458		}
13459		return graphql.Null
13460	}
13461	return ec._LabelEdge(ctx, sel, v)
13462}
13463
13464func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13465	return ec.unmarshalInputNewBugInput(ctx, v)
13466}
13467
13468func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13469	return ec._NewBugPayload(ctx, sel, &v)
13470}
13471
13472func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13473	if v == nil {
13474		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13475			ec.Errorf(ctx, "must not be null")
13476		}
13477		return graphql.Null
13478	}
13479	return ec._NewBugPayload(ctx, sel, v)
13480}
13481
13482func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13483	return ec.unmarshalInputOpenBugInput(ctx, v)
13484}
13485
13486func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13487	return ec._OpenBugPayload(ctx, sel, &v)
13488}
13489
13490func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13491	if v == nil {
13492		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13493			ec.Errorf(ctx, "must not be null")
13494		}
13495		return graphql.Null
13496	}
13497	return ec._OpenBugPayload(ctx, sel, v)
13498}
13499
13500func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13501	if v == nil {
13502		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13503			ec.Errorf(ctx, "must not be null")
13504		}
13505		return graphql.Null
13506	}
13507	return ec._Operation(ctx, sel, v)
13508}
13509
13510func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13511	ret := make(graphql.Array, len(v))
13512	var wg sync.WaitGroup
13513	isLen1 := len(v) == 1
13514	if !isLen1 {
13515		wg.Add(len(v))
13516	}
13517	for i := range v {
13518		i := i
13519		fc := &graphql.FieldContext{
13520			Index:  &i,
13521			Result: &v[i],
13522		}
13523		ctx := graphql.WithFieldContext(ctx, fc)
13524		f := func(i int) {
13525			defer func() {
13526				if r := recover(); r != nil {
13527					ec.Error(ctx, ec.Recover(ctx, r))
13528					ret = nil
13529				}
13530			}()
13531			if !isLen1 {
13532				defer wg.Done()
13533			}
13534			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13535		}
13536		if isLen1 {
13537			f(i)
13538		} else {
13539			go f(i)
13540		}
13541
13542	}
13543	wg.Wait()
13544	return ret
13545}
13546
13547func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13548	return ec._OperationConnection(ctx, sel, &v)
13549}
13550
13551func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13552	if v == nil {
13553		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13554			ec.Errorf(ctx, "must not be null")
13555		}
13556		return graphql.Null
13557	}
13558	return ec._OperationConnection(ctx, sel, v)
13559}
13560
13561func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13562	return ec._OperationEdge(ctx, sel, &v)
13563}
13564
13565func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13566	ret := make(graphql.Array, len(v))
13567	var wg sync.WaitGroup
13568	isLen1 := len(v) == 1
13569	if !isLen1 {
13570		wg.Add(len(v))
13571	}
13572	for i := range v {
13573		i := i
13574		fc := &graphql.FieldContext{
13575			Index:  &i,
13576			Result: &v[i],
13577		}
13578		ctx := graphql.WithFieldContext(ctx, fc)
13579		f := func(i int) {
13580			defer func() {
13581				if r := recover(); r != nil {
13582					ec.Error(ctx, ec.Recover(ctx, r))
13583					ret = nil
13584				}
13585			}()
13586			if !isLen1 {
13587				defer wg.Done()
13588			}
13589			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13590		}
13591		if isLen1 {
13592			f(i)
13593		} else {
13594			go f(i)
13595		}
13596
13597	}
13598	wg.Wait()
13599	return ret
13600}
13601
13602func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
13603	if v == nil {
13604		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13605			ec.Errorf(ctx, "must not be null")
13606		}
13607		return graphql.Null
13608	}
13609	return ec._OperationEdge(ctx, sel, v)
13610}
13611
13612func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
13613	return ec._PageInfo(ctx, sel, &v)
13614}
13615
13616func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
13617	if v == nil {
13618		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13619			ec.Errorf(ctx, "must not be null")
13620		}
13621		return graphql.Null
13622	}
13623	return ec._PageInfo(ctx, sel, v)
13624}
13625
13626func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
13627	return ec._SetStatusOperation(ctx, sel, &v)
13628}
13629
13630func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
13631	if v == nil {
13632		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13633			ec.Errorf(ctx, "must not be null")
13634		}
13635		return graphql.Null
13636	}
13637	return ec._SetStatusOperation(ctx, sel, v)
13638}
13639
13640func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
13641	return ec.unmarshalInputSetTitleInput(ctx, v)
13642}
13643
13644func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
13645	return ec._SetTitleOperation(ctx, sel, &v)
13646}
13647
13648func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
13649	if v == nil {
13650		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13651			ec.Errorf(ctx, "must not be null")
13652		}
13653		return graphql.Null
13654	}
13655	return ec._SetTitleOperation(ctx, sel, v)
13656}
13657
13658func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
13659	return ec._SetTitlePayload(ctx, sel, &v)
13660}
13661
13662func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
13663	if v == nil {
13664		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13665			ec.Errorf(ctx, "must not be null")
13666		}
13667		return graphql.Null
13668	}
13669	return ec._SetTitlePayload(ctx, sel, v)
13670}
13671
13672func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
13673	var res models.Status
13674	return res, res.UnmarshalGQL(v)
13675}
13676
13677func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
13678	return v
13679}
13680
13681func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
13682	return graphql.UnmarshalString(v)
13683}
13684
13685func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13686	res := graphql.MarshalString(v)
13687	if res == graphql.Null {
13688		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13689			ec.Errorf(ctx, "must not be null")
13690		}
13691	}
13692	return res
13693}
13694
13695func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
13696	return graphql.UnmarshalTime(v)
13697}
13698
13699func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
13700	res := graphql.MarshalTime(v)
13701	if res == graphql.Null {
13702		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13703			ec.Errorf(ctx, "must not be null")
13704		}
13705	}
13706	return res
13707}
13708
13709func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
13710	if v == nil {
13711		return nil, nil
13712	}
13713	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
13714	return &res, err
13715}
13716
13717func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
13718	if v == nil {
13719		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13720			ec.Errorf(ctx, "must not be null")
13721		}
13722		return graphql.Null
13723	}
13724	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
13725}
13726
13727func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
13728	if v == nil {
13729		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13730			ec.Errorf(ctx, "must not be null")
13731		}
13732		return graphql.Null
13733	}
13734	return ec._TimelineItem(ctx, sel, v)
13735}
13736
13737func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
13738	ret := make(graphql.Array, len(v))
13739	var wg sync.WaitGroup
13740	isLen1 := len(v) == 1
13741	if !isLen1 {
13742		wg.Add(len(v))
13743	}
13744	for i := range v {
13745		i := i
13746		fc := &graphql.FieldContext{
13747			Index:  &i,
13748			Result: &v[i],
13749		}
13750		ctx := graphql.WithFieldContext(ctx, fc)
13751		f := func(i int) {
13752			defer func() {
13753				if r := recover(); r != nil {
13754					ec.Error(ctx, ec.Recover(ctx, r))
13755					ret = nil
13756				}
13757			}()
13758			if !isLen1 {
13759				defer wg.Done()
13760			}
13761			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
13762		}
13763		if isLen1 {
13764			f(i)
13765		} else {
13766			go f(i)
13767		}
13768
13769	}
13770	wg.Wait()
13771	return ret
13772}
13773
13774func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
13775	return ec._TimelineItemConnection(ctx, sel, &v)
13776}
13777
13778func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
13779	if v == nil {
13780		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13781			ec.Errorf(ctx, "must not be null")
13782		}
13783		return graphql.Null
13784	}
13785	return ec._TimelineItemConnection(ctx, sel, v)
13786}
13787
13788func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
13789	return ec._TimelineItemEdge(ctx, sel, &v)
13790}
13791
13792func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
13793	ret := make(graphql.Array, len(v))
13794	var wg sync.WaitGroup
13795	isLen1 := len(v) == 1
13796	if !isLen1 {
13797		wg.Add(len(v))
13798	}
13799	for i := range v {
13800		i := i
13801		fc := &graphql.FieldContext{
13802			Index:  &i,
13803			Result: &v[i],
13804		}
13805		ctx := graphql.WithFieldContext(ctx, fc)
13806		f := func(i int) {
13807			defer func() {
13808				if r := recover(); r != nil {
13809					ec.Error(ctx, ec.Recover(ctx, r))
13810					ret = nil
13811				}
13812			}()
13813			if !isLen1 {
13814				defer wg.Done()
13815			}
13816			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
13817		}
13818		if isLen1 {
13819			f(i)
13820		} else {
13821			go f(i)
13822		}
13823
13824	}
13825	wg.Wait()
13826	return ret
13827}
13828
13829func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
13830	if v == nil {
13831		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13832			ec.Errorf(ctx, "must not be null")
13833		}
13834		return graphql.Null
13835	}
13836	return ec._TimelineItemEdge(ctx, sel, v)
13837}
13838
13839func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
13840	return ec.___Directive(ctx, sel, &v)
13841}
13842
13843func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
13844	ret := make(graphql.Array, len(v))
13845	var wg sync.WaitGroup
13846	isLen1 := len(v) == 1
13847	if !isLen1 {
13848		wg.Add(len(v))
13849	}
13850	for i := range v {
13851		i := i
13852		fc := &graphql.FieldContext{
13853			Index:  &i,
13854			Result: &v[i],
13855		}
13856		ctx := graphql.WithFieldContext(ctx, fc)
13857		f := func(i int) {
13858			defer func() {
13859				if r := recover(); r != nil {
13860					ec.Error(ctx, ec.Recover(ctx, r))
13861					ret = nil
13862				}
13863			}()
13864			if !isLen1 {
13865				defer wg.Done()
13866			}
13867			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
13868		}
13869		if isLen1 {
13870			f(i)
13871		} else {
13872			go f(i)
13873		}
13874
13875	}
13876	wg.Wait()
13877	return ret
13878}
13879
13880func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
13881	return graphql.UnmarshalString(v)
13882}
13883
13884func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13885	res := graphql.MarshalString(v)
13886	if res == graphql.Null {
13887		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13888			ec.Errorf(ctx, "must not be null")
13889		}
13890	}
13891	return res
13892}
13893
13894func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
13895	var vSlice []interface{}
13896	if v != nil {
13897		if tmp1, ok := v.([]interface{}); ok {
13898			vSlice = tmp1
13899		} else {
13900			vSlice = []interface{}{v}
13901		}
13902	}
13903	var err error
13904	res := make([]string, len(vSlice))
13905	for i := range vSlice {
13906		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
13907		if err != nil {
13908			return nil, err
13909		}
13910	}
13911	return res, nil
13912}
13913
13914func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
13915	ret := make(graphql.Array, len(v))
13916	var wg sync.WaitGroup
13917	isLen1 := len(v) == 1
13918	if !isLen1 {
13919		wg.Add(len(v))
13920	}
13921	for i := range v {
13922		i := i
13923		fc := &graphql.FieldContext{
13924			Index:  &i,
13925			Result: &v[i],
13926		}
13927		ctx := graphql.WithFieldContext(ctx, fc)
13928		f := func(i int) {
13929			defer func() {
13930				if r := recover(); r != nil {
13931					ec.Error(ctx, ec.Recover(ctx, r))
13932					ret = nil
13933				}
13934			}()
13935			if !isLen1 {
13936				defer wg.Done()
13937			}
13938			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
13939		}
13940		if isLen1 {
13941			f(i)
13942		} else {
13943			go f(i)
13944		}
13945
13946	}
13947	wg.Wait()
13948	return ret
13949}
13950
13951func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
13952	return ec.___EnumValue(ctx, sel, &v)
13953}
13954
13955func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
13956	return ec.___Field(ctx, sel, &v)
13957}
13958
13959func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
13960	return ec.___InputValue(ctx, sel, &v)
13961}
13962
13963func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
13964	ret := make(graphql.Array, len(v))
13965	var wg sync.WaitGroup
13966	isLen1 := len(v) == 1
13967	if !isLen1 {
13968		wg.Add(len(v))
13969	}
13970	for i := range v {
13971		i := i
13972		fc := &graphql.FieldContext{
13973			Index:  &i,
13974			Result: &v[i],
13975		}
13976		ctx := graphql.WithFieldContext(ctx, fc)
13977		f := func(i int) {
13978			defer func() {
13979				if r := recover(); r != nil {
13980					ec.Error(ctx, ec.Recover(ctx, r))
13981					ret = nil
13982				}
13983			}()
13984			if !isLen1 {
13985				defer wg.Done()
13986			}
13987			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
13988		}
13989		if isLen1 {
13990			f(i)
13991		} else {
13992			go f(i)
13993		}
13994
13995	}
13996	wg.Wait()
13997	return ret
13998}
13999
14000func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14001	return ec.___Type(ctx, sel, &v)
14002}
14003
14004func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14005	ret := make(graphql.Array, len(v))
14006	var wg sync.WaitGroup
14007	isLen1 := len(v) == 1
14008	if !isLen1 {
14009		wg.Add(len(v))
14010	}
14011	for i := range v {
14012		i := i
14013		fc := &graphql.FieldContext{
14014			Index:  &i,
14015			Result: &v[i],
14016		}
14017		ctx := graphql.WithFieldContext(ctx, fc)
14018		f := func(i int) {
14019			defer func() {
14020				if r := recover(); r != nil {
14021					ec.Error(ctx, ec.Recover(ctx, r))
14022					ret = nil
14023				}
14024			}()
14025			if !isLen1 {
14026				defer wg.Done()
14027			}
14028			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14029		}
14030		if isLen1 {
14031			f(i)
14032		} else {
14033			go f(i)
14034		}
14035
14036	}
14037	wg.Wait()
14038	return ret
14039}
14040
14041func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14042	if v == nil {
14043		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14044			ec.Errorf(ctx, "must not be null")
14045		}
14046		return graphql.Null
14047	}
14048	return ec.___Type(ctx, sel, v)
14049}
14050
14051func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14052	return graphql.UnmarshalString(v)
14053}
14054
14055func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14056	res := graphql.MarshalString(v)
14057	if res == graphql.Null {
14058		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14059			ec.Errorf(ctx, "must not be null")
14060		}
14061	}
14062	return res
14063}
14064
14065func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14066	return graphql.UnmarshalBoolean(v)
14067}
14068
14069func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14070	return graphql.MarshalBoolean(v)
14071}
14072
14073func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14074	if v == nil {
14075		return nil, nil
14076	}
14077	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14078	return &res, err
14079}
14080
14081func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14082	if v == nil {
14083		return graphql.Null
14084	}
14085	return ec.marshalOBoolean2bool(ctx, sel, *v)
14086}
14087
14088func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14089	if v == nil {
14090		return graphql.Null
14091	}
14092	return ec._Bug(ctx, sel, v)
14093}
14094
14095func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14096	return ec.unmarshalInputChangeLabelInput(ctx, v)
14097}
14098
14099func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14100	if v == nil {
14101		return nil, nil
14102	}
14103	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14104	return &res, err
14105}
14106
14107func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14108	var vSlice []interface{}
14109	if v != nil {
14110		if tmp1, ok := v.([]interface{}); ok {
14111			vSlice = tmp1
14112		} else {
14113			vSlice = []interface{}{v}
14114		}
14115	}
14116	var err error
14117	res := make([]git.Hash, len(vSlice))
14118	for i := range vSlice {
14119		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14120		if err != nil {
14121			return nil, err
14122		}
14123	}
14124	return res, nil
14125}
14126
14127func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14128	if v == nil {
14129		return graphql.Null
14130	}
14131	ret := make(graphql.Array, len(v))
14132	for i := range v {
14133		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14134	}
14135
14136	return ret
14137}
14138
14139func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14140	if v == nil {
14141		return graphql.Null
14142	}
14143	return ec._Identity(ctx, sel, v)
14144}
14145
14146func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14147	return graphql.UnmarshalInt(v)
14148}
14149
14150func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14151	return graphql.MarshalInt(v)
14152}
14153
14154func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14155	if v == nil {
14156		return nil, nil
14157	}
14158	res, err := ec.unmarshalOInt2int(ctx, v)
14159	return &res, err
14160}
14161
14162func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14163	if v == nil {
14164		return graphql.Null
14165	}
14166	return ec.marshalOInt2int(ctx, sel, *v)
14167}
14168
14169func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14170	return ec._LabelChangeResult(ctx, sel, &v)
14171}
14172
14173func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14174	if v == nil {
14175		return graphql.Null
14176	}
14177	return ec._LabelChangeResult(ctx, sel, v)
14178}
14179
14180func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14181	return ec._Repository(ctx, sel, &v)
14182}
14183
14184func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14185	if v == nil {
14186		return graphql.Null
14187	}
14188	return ec._Repository(ctx, sel, v)
14189}
14190
14191func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14192	return graphql.UnmarshalString(v)
14193}
14194
14195func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14196	return graphql.MarshalString(v)
14197}
14198
14199func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14200	var vSlice []interface{}
14201	if v != nil {
14202		if tmp1, ok := v.([]interface{}); ok {
14203			vSlice = tmp1
14204		} else {
14205			vSlice = []interface{}{v}
14206		}
14207	}
14208	var err error
14209	res := make([]string, len(vSlice))
14210	for i := range vSlice {
14211		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14212		if err != nil {
14213			return nil, err
14214		}
14215	}
14216	return res, nil
14217}
14218
14219func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14220	if v == nil {
14221		return graphql.Null
14222	}
14223	ret := make(graphql.Array, len(v))
14224	for i := range v {
14225		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14226	}
14227
14228	return ret
14229}
14230
14231func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14232	if v == nil {
14233		return nil, nil
14234	}
14235	res, err := ec.unmarshalOString2string(ctx, v)
14236	return &res, err
14237}
14238
14239func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14240	if v == nil {
14241		return graphql.Null
14242	}
14243	return ec.marshalOString2string(ctx, sel, *v)
14244}
14245
14246func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14247	if v == nil {
14248		return graphql.Null
14249	}
14250	ret := make(graphql.Array, len(v))
14251	var wg sync.WaitGroup
14252	isLen1 := len(v) == 1
14253	if !isLen1 {
14254		wg.Add(len(v))
14255	}
14256	for i := range v {
14257		i := i
14258		fc := &graphql.FieldContext{
14259			Index:  &i,
14260			Result: &v[i],
14261		}
14262		ctx := graphql.WithFieldContext(ctx, fc)
14263		f := func(i int) {
14264			defer func() {
14265				if r := recover(); r != nil {
14266					ec.Error(ctx, ec.Recover(ctx, r))
14267					ret = nil
14268				}
14269			}()
14270			if !isLen1 {
14271				defer wg.Done()
14272			}
14273			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14274		}
14275		if isLen1 {
14276			f(i)
14277		} else {
14278			go f(i)
14279		}
14280
14281	}
14282	wg.Wait()
14283	return ret
14284}
14285
14286func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14287	if v == nil {
14288		return graphql.Null
14289	}
14290	ret := make(graphql.Array, len(v))
14291	var wg sync.WaitGroup
14292	isLen1 := len(v) == 1
14293	if !isLen1 {
14294		wg.Add(len(v))
14295	}
14296	for i := range v {
14297		i := i
14298		fc := &graphql.FieldContext{
14299			Index:  &i,
14300			Result: &v[i],
14301		}
14302		ctx := graphql.WithFieldContext(ctx, fc)
14303		f := func(i int) {
14304			defer func() {
14305				if r := recover(); r != nil {
14306					ec.Error(ctx, ec.Recover(ctx, r))
14307					ret = nil
14308				}
14309			}()
14310			if !isLen1 {
14311				defer wg.Done()
14312			}
14313			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14314		}
14315		if isLen1 {
14316			f(i)
14317		} else {
14318			go f(i)
14319		}
14320
14321	}
14322	wg.Wait()
14323	return ret
14324}
14325
14326func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14327	if v == nil {
14328		return graphql.Null
14329	}
14330	ret := make(graphql.Array, len(v))
14331	var wg sync.WaitGroup
14332	isLen1 := len(v) == 1
14333	if !isLen1 {
14334		wg.Add(len(v))
14335	}
14336	for i := range v {
14337		i := i
14338		fc := &graphql.FieldContext{
14339			Index:  &i,
14340			Result: &v[i],
14341		}
14342		ctx := graphql.WithFieldContext(ctx, fc)
14343		f := func(i int) {
14344			defer func() {
14345				if r := recover(); r != nil {
14346					ec.Error(ctx, ec.Recover(ctx, r))
14347					ret = nil
14348				}
14349			}()
14350			if !isLen1 {
14351				defer wg.Done()
14352			}
14353			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14354		}
14355		if isLen1 {
14356			f(i)
14357		} else {
14358			go f(i)
14359		}
14360
14361	}
14362	wg.Wait()
14363	return ret
14364}
14365
14366func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14367	return ec.___Schema(ctx, sel, &v)
14368}
14369
14370func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14371	if v == nil {
14372		return graphql.Null
14373	}
14374	return ec.___Schema(ctx, sel, v)
14375}
14376
14377func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14378	return ec.___Type(ctx, sel, &v)
14379}
14380
14381func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14382	if v == nil {
14383		return graphql.Null
14384	}
14385	ret := make(graphql.Array, len(v))
14386	var wg sync.WaitGroup
14387	isLen1 := len(v) == 1
14388	if !isLen1 {
14389		wg.Add(len(v))
14390	}
14391	for i := range v {
14392		i := i
14393		fc := &graphql.FieldContext{
14394			Index:  &i,
14395			Result: &v[i],
14396		}
14397		ctx := graphql.WithFieldContext(ctx, fc)
14398		f := func(i int) {
14399			defer func() {
14400				if r := recover(); r != nil {
14401					ec.Error(ctx, ec.Recover(ctx, r))
14402					ret = nil
14403				}
14404			}()
14405			if !isLen1 {
14406				defer wg.Done()
14407			}
14408			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14409		}
14410		if isLen1 {
14411			f(i)
14412		} else {
14413			go f(i)
14414		}
14415
14416	}
14417	wg.Wait()
14418	return ret
14419}
14420
14421func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14422	if v == nil {
14423		return graphql.Null
14424	}
14425	return ec.___Type(ctx, sel, v)
14426}
14427
14428// endregion ***************************** type.gotpl *****************************