1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
    2
    3package graph
    4
    5import (
    6	"bytes"
    7	"context"
    8	"errors"
    9	"fmt"
   10	"image/color"
   11	"strconv"
   12	"sync"
   13	"sync/atomic"
   14	"time"
   15
   16	"github.com/99designs/gqlgen/graphql"
   17	"github.com/99designs/gqlgen/graphql/introspection"
   18	"github.com/MichaelMure/git-bug/bug"
   19	"github.com/MichaelMure/git-bug/graphql/models"
   20	"github.com/MichaelMure/git-bug/util/git"
   21	"github.com/vektah/gqlparser"
   22	"github.com/vektah/gqlparser/ast"
   23)
   24
   25// region    ************************** generated!.gotpl **************************
   26
   27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
   28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
   29	return &executableSchema{
   30		resolvers:  cfg.Resolvers,
   31		directives: cfg.Directives,
   32		complexity: cfg.Complexity,
   33	}
   34}
   35
   36type Config struct {
   37	Resolvers  ResolverRoot
   38	Directives DirectiveRoot
   39	Complexity ComplexityRoot
   40}
   41
   42type ResolverRoot interface {
   43	AddCommentOperation() AddCommentOperationResolver
   44	AddCommentTimelineItem() AddCommentTimelineItemResolver
   45	Bug() BugResolver
   46	Color() ColorResolver
   47	Comment() CommentResolver
   48	CommentHistoryStep() CommentHistoryStepResolver
   49	CreateOperation() CreateOperationResolver
   50	CreateTimelineItem() CreateTimelineItemResolver
   51	EditCommentOperation() EditCommentOperationResolver
   52	Identity() IdentityResolver
   53	Label() LabelResolver
   54	LabelChangeOperation() LabelChangeOperationResolver
   55	LabelChangeResult() LabelChangeResultResolver
   56	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
   57	Mutation() MutationResolver
   58	Query() QueryResolver
   59	Repository() RepositoryResolver
   60	SetStatusOperation() SetStatusOperationResolver
   61	SetStatusTimelineItem() SetStatusTimelineItemResolver
   62	SetTitleOperation() SetTitleOperationResolver
   63	SetTitleTimelineItem() SetTitleTimelineItemResolver
   64}
   65
   66type DirectiveRoot struct {
   67}
   68
   69type ComplexityRoot struct {
   70	AddCommentOperation struct {
   71		Author  func(childComplexity int) int
   72		Date    func(childComplexity int) int
   73		Files   func(childComplexity int) int
   74		ID      func(childComplexity int) int
   75		Message func(childComplexity int) int
   76	}
   77
   78	AddCommentPayload struct {
   79		Bug              func(childComplexity int) int
   80		ClientMutationID func(childComplexity int) int
   81		Operation        func(childComplexity int) int
   82	}
   83
   84	AddCommentTimelineItem struct {
   85		Author         func(childComplexity int) int
   86		CreatedAt      func(childComplexity int) int
   87		Edited         func(childComplexity int) int
   88		Files          func(childComplexity int) int
   89		History        func(childComplexity int) int
   90		ID             func(childComplexity int) int
   91		LastEdit       func(childComplexity int) int
   92		Message        func(childComplexity int) int
   93		MessageIsEmpty func(childComplexity int) int
   94	}
   95
   96	Bug struct {
   97		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
   98		Author       func(childComplexity int) int
   99		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
  100		CreatedAt    func(childComplexity int) int
  101		HumanID      func(childComplexity int) int
  102		ID           func(childComplexity int) int
  103		Labels       func(childComplexity int) int
  104		LastEdit     func(childComplexity int) int
  105		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
  106		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
  107		Status       func(childComplexity int) int
  108		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
  109		Title        func(childComplexity int) int
  110	}
  111
  112	BugConnection struct {
  113		Edges      func(childComplexity int) int
  114		Nodes      func(childComplexity int) int
  115		PageInfo   func(childComplexity int) int
  116		TotalCount func(childComplexity int) int
  117	}
  118
  119	BugEdge struct {
  120		Cursor func(childComplexity int) int
  121		Node   func(childComplexity int) int
  122	}
  123
  124	ChangeLabelPayload struct {
  125		Bug              func(childComplexity int) int
  126		ClientMutationID func(childComplexity int) int
  127		Operation        func(childComplexity int) int
  128		Results          func(childComplexity int) int
  129	}
  130
  131	CloseBugPayload struct {
  132		Bug              func(childComplexity int) int
  133		ClientMutationID func(childComplexity int) int
  134		Operation        func(childComplexity int) int
  135	}
  136
  137	Color struct {
  138		B func(childComplexity int) int
  139		G func(childComplexity int) int
  140		R func(childComplexity int) int
  141	}
  142
  143	Comment struct {
  144		Author  func(childComplexity int) int
  145		Files   func(childComplexity int) int
  146		Message func(childComplexity int) int
  147	}
  148
  149	CommentConnection struct {
  150		Edges      func(childComplexity int) int
  151		Nodes      func(childComplexity int) int
  152		PageInfo   func(childComplexity int) int
  153		TotalCount func(childComplexity int) int
  154	}
  155
  156	CommentEdge struct {
  157		Cursor func(childComplexity int) int
  158		Node   func(childComplexity int) int
  159	}
  160
  161	CommentHistoryStep struct {
  162		Date    func(childComplexity int) int
  163		Message func(childComplexity int) int
  164	}
  165
  166	CreateOperation struct {
  167		Author  func(childComplexity int) int
  168		Date    func(childComplexity int) int
  169		Files   func(childComplexity int) int
  170		ID      func(childComplexity int) int
  171		Message func(childComplexity int) int
  172		Title   func(childComplexity int) int
  173	}
  174
  175	CreateTimelineItem struct {
  176		Author         func(childComplexity int) int
  177		CreatedAt      func(childComplexity int) int
  178		Edited         func(childComplexity int) int
  179		Files          func(childComplexity int) int
  180		History        func(childComplexity int) int
  181		ID             func(childComplexity int) int
  182		LastEdit       func(childComplexity int) int
  183		Message        func(childComplexity int) int
  184		MessageIsEmpty func(childComplexity int) int
  185	}
  186
  187	EditCommentOperation struct {
  188		Author  func(childComplexity int) int
  189		Date    func(childComplexity int) int
  190		Files   func(childComplexity int) int
  191		ID      func(childComplexity int) int
  192		Message func(childComplexity int) int
  193		Target  func(childComplexity int) int
  194	}
  195
  196	Identity struct {
  197		AvatarUrl   func(childComplexity int) int
  198		DisplayName func(childComplexity int) int
  199		Email       func(childComplexity int) int
  200		HumanID     func(childComplexity int) int
  201		ID          func(childComplexity int) int
  202		IsProtected func(childComplexity int) int
  203		Name        func(childComplexity int) int
  204	}
  205
  206	IdentityConnection struct {
  207		Edges      func(childComplexity int) int
  208		Nodes      func(childComplexity int) int
  209		PageInfo   func(childComplexity int) int
  210		TotalCount func(childComplexity int) int
  211	}
  212
  213	IdentityEdge struct {
  214		Cursor func(childComplexity int) int
  215		Node   func(childComplexity int) int
  216	}
  217
  218	Label struct {
  219		Color func(childComplexity int) int
  220		Name  func(childComplexity int) int
  221	}
  222
  223	LabelChangeOperation struct {
  224		Added   func(childComplexity int) int
  225		Author  func(childComplexity int) int
  226		Date    func(childComplexity int) int
  227		ID      func(childComplexity int) int
  228		Removed func(childComplexity int) int
  229	}
  230
  231	LabelChangeResult struct {
  232		Label  func(childComplexity int) int
  233		Status func(childComplexity int) int
  234	}
  235
  236	LabelChangeTimelineItem struct {
  237		Added   func(childComplexity int) int
  238		Author  func(childComplexity int) int
  239		Date    func(childComplexity int) int
  240		ID      func(childComplexity int) int
  241		Removed func(childComplexity int) int
  242	}
  243
  244	LabelConnection struct {
  245		Edges      func(childComplexity int) int
  246		Nodes      func(childComplexity int) int
  247		PageInfo   func(childComplexity int) int
  248		TotalCount func(childComplexity int) int
  249	}
  250
  251	LabelEdge struct {
  252		Cursor func(childComplexity int) int
  253		Node   func(childComplexity int) int
  254	}
  255
  256	Mutation struct {
  257		AddComment   func(childComplexity int, input models.AddCommentInput) int
  258		ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
  259		CloseBug     func(childComplexity int, input models.CloseBugInput) int
  260		NewBug       func(childComplexity int, input models.NewBugInput) int
  261		OpenBug      func(childComplexity int, input models.OpenBugInput) int
  262		SetTitle     func(childComplexity int, input models.SetTitleInput) int
  263	}
  264
  265	NewBugPayload struct {
  266		Bug              func(childComplexity int) int
  267		ClientMutationID func(childComplexity int) int
  268		Operation        func(childComplexity int) int
  269	}
  270
  271	OpenBugPayload struct {
  272		Bug              func(childComplexity int) int
  273		ClientMutationID func(childComplexity int) int
  274		Operation        func(childComplexity int) int
  275	}
  276
  277	OperationConnection struct {
  278		Edges      func(childComplexity int) int
  279		Nodes      func(childComplexity int) int
  280		PageInfo   func(childComplexity int) int
  281		TotalCount func(childComplexity int) int
  282	}
  283
  284	OperationEdge struct {
  285		Cursor func(childComplexity int) int
  286		Node   func(childComplexity int) int
  287	}
  288
  289	PageInfo struct {
  290		EndCursor       func(childComplexity int) int
  291		HasNextPage     func(childComplexity int) int
  292		HasPreviousPage func(childComplexity int) int
  293		StartCursor     func(childComplexity int) int
  294	}
  295
  296	Query struct {
  297		Repository func(childComplexity int, ref *string) int
  298	}
  299
  300	Repository struct {
  301		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  302		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  303		Bug           func(childComplexity int, prefix string) int
  304		Identity      func(childComplexity int, prefix string) int
  305		Name          func(childComplexity int) int
  306		UserIdentity  func(childComplexity int) int
  307		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  308	}
  309
  310	SetStatusOperation struct {
  311		Author func(childComplexity int) int
  312		Date   func(childComplexity int) int
  313		ID     func(childComplexity int) int
  314		Status func(childComplexity int) int
  315	}
  316
  317	SetStatusTimelineItem struct {
  318		Author func(childComplexity int) int
  319		Date   func(childComplexity int) int
  320		ID     func(childComplexity int) int
  321		Status func(childComplexity int) int
  322	}
  323
  324	SetTitleOperation struct {
  325		Author func(childComplexity int) int
  326		Date   func(childComplexity int) int
  327		ID     func(childComplexity int) int
  328		Title  func(childComplexity int) int
  329		Was    func(childComplexity int) int
  330	}
  331
  332	SetTitlePayload struct {
  333		Bug              func(childComplexity int) int
  334		ClientMutationID func(childComplexity int) int
  335		Operation        func(childComplexity int) int
  336	}
  337
  338	SetTitleTimelineItem struct {
  339		Author func(childComplexity int) int
  340		Date   func(childComplexity int) int
  341		ID     func(childComplexity int) int
  342		Title  func(childComplexity int) int
  343		Was    func(childComplexity int) int
  344	}
  345
  346	TimelineItemConnection struct {
  347		Edges      func(childComplexity int) int
  348		Nodes      func(childComplexity int) int
  349		PageInfo   func(childComplexity int) int
  350		TotalCount func(childComplexity int) int
  351	}
  352
  353	TimelineItemEdge struct {
  354		Cursor func(childComplexity int) int
  355		Node   func(childComplexity int) int
  356	}
  357}
  358
  359type AddCommentOperationResolver interface {
  360	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  361	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
  362	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  363}
  364type AddCommentTimelineItemResolver interface {
  365	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  366	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
  367
  368	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  369	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  370}
  371type BugResolver interface {
  372	ID(ctx context.Context, obj models.BugWrapper) (string, error)
  373	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  374	Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
  375
  376	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  377	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  378	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  379	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  380	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  381}
  382type ColorResolver interface {
  383	R(ctx context.Context, obj *color.RGBA) (int, error)
  384	G(ctx context.Context, obj *color.RGBA) (int, error)
  385	B(ctx context.Context, obj *color.RGBA) (int, error)
  386}
  387type CommentResolver interface {
  388	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
  389}
  390type CommentHistoryStepResolver interface {
  391	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  392}
  393type CreateOperationResolver interface {
  394	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  395	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
  396	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  397}
  398type CreateTimelineItemResolver interface {
  399	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  400	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
  401
  402	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  403	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  404}
  405type EditCommentOperationResolver interface {
  406	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  407	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
  408	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  409	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  410}
  411type IdentityResolver interface {
  412	ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  413	HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  414}
  415type LabelResolver interface {
  416	Name(ctx context.Context, obj *bug.Label) (string, error)
  417	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  418}
  419type LabelChangeOperationResolver interface {
  420	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  421	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
  422	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  423}
  424type LabelChangeResultResolver interface {
  425	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  426}
  427type LabelChangeTimelineItemResolver interface {
  428	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  429	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
  430	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  431}
  432type MutationResolver interface {
  433	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  434	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  435	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  436	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  437	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  438	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  439}
  440type QueryResolver interface {
  441	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  442}
  443type RepositoryResolver interface {
  444	Name(ctx context.Context, obj *models.Repository) (*string, error)
  445	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  446	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  447	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  448	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  449	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  450	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  451}
  452type SetStatusOperationResolver interface {
  453	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  454	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
  455	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  456	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  457}
  458type SetStatusTimelineItemResolver interface {
  459	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  460	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
  461	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  462	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  463}
  464type SetTitleOperationResolver interface {
  465	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  466	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
  467	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  468}
  469type SetTitleTimelineItemResolver interface {
  470	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  471	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
  472	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  473}
  474
  475type executableSchema struct {
  476	resolvers  ResolverRoot
  477	directives DirectiveRoot
  478	complexity ComplexityRoot
  479}
  480
  481func (e *executableSchema) Schema() *ast.Schema {
  482	return parsedSchema
  483}
  484
  485func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  486	ec := executionContext{nil, e}
  487	_ = ec
  488	switch typeName + "." + field {
  489
  490	case "AddCommentOperation.author":
  491		if e.complexity.AddCommentOperation.Author == nil {
  492			break
  493		}
  494
  495		return e.complexity.AddCommentOperation.Author(childComplexity), true
  496
  497	case "AddCommentOperation.date":
  498		if e.complexity.AddCommentOperation.Date == nil {
  499			break
  500		}
  501
  502		return e.complexity.AddCommentOperation.Date(childComplexity), true
  503
  504	case "AddCommentOperation.files":
  505		if e.complexity.AddCommentOperation.Files == nil {
  506			break
  507		}
  508
  509		return e.complexity.AddCommentOperation.Files(childComplexity), true
  510
  511	case "AddCommentOperation.id":
  512		if e.complexity.AddCommentOperation.ID == nil {
  513			break
  514		}
  515
  516		return e.complexity.AddCommentOperation.ID(childComplexity), true
  517
  518	case "AddCommentOperation.message":
  519		if e.complexity.AddCommentOperation.Message == nil {
  520			break
  521		}
  522
  523		return e.complexity.AddCommentOperation.Message(childComplexity), true
  524
  525	case "AddCommentPayload.bug":
  526		if e.complexity.AddCommentPayload.Bug == nil {
  527			break
  528		}
  529
  530		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  531
  532	case "AddCommentPayload.clientMutationId":
  533		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  534			break
  535		}
  536
  537		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  538
  539	case "AddCommentPayload.operation":
  540		if e.complexity.AddCommentPayload.Operation == nil {
  541			break
  542		}
  543
  544		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  545
  546	case "AddCommentTimelineItem.author":
  547		if e.complexity.AddCommentTimelineItem.Author == nil {
  548			break
  549		}
  550
  551		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  552
  553	case "AddCommentTimelineItem.createdAt":
  554		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  555			break
  556		}
  557
  558		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  559
  560	case "AddCommentTimelineItem.edited":
  561		if e.complexity.AddCommentTimelineItem.Edited == nil {
  562			break
  563		}
  564
  565		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  566
  567	case "AddCommentTimelineItem.files":
  568		if e.complexity.AddCommentTimelineItem.Files == nil {
  569			break
  570		}
  571
  572		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  573
  574	case "AddCommentTimelineItem.history":
  575		if e.complexity.AddCommentTimelineItem.History == nil {
  576			break
  577		}
  578
  579		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  580
  581	case "AddCommentTimelineItem.id":
  582		if e.complexity.AddCommentTimelineItem.ID == nil {
  583			break
  584		}
  585
  586		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  587
  588	case "AddCommentTimelineItem.lastEdit":
  589		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  590			break
  591		}
  592
  593		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  594
  595	case "AddCommentTimelineItem.message":
  596		if e.complexity.AddCommentTimelineItem.Message == nil {
  597			break
  598		}
  599
  600		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  601
  602	case "AddCommentTimelineItem.messageIsEmpty":
  603		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  604			break
  605		}
  606
  607		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  608
  609	case "Bug.actors":
  610		if e.complexity.Bug.Actors == nil {
  611			break
  612		}
  613
  614		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  615		if err != nil {
  616			return 0, false
  617		}
  618
  619		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  620
  621	case "Bug.author":
  622		if e.complexity.Bug.Author == nil {
  623			break
  624		}
  625
  626		return e.complexity.Bug.Author(childComplexity), true
  627
  628	case "Bug.comments":
  629		if e.complexity.Bug.Comments == nil {
  630			break
  631		}
  632
  633		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  634		if err != nil {
  635			return 0, false
  636		}
  637
  638		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  639
  640	case "Bug.createdAt":
  641		if e.complexity.Bug.CreatedAt == nil {
  642			break
  643		}
  644
  645		return e.complexity.Bug.CreatedAt(childComplexity), true
  646
  647	case "Bug.humanId":
  648		if e.complexity.Bug.HumanID == nil {
  649			break
  650		}
  651
  652		return e.complexity.Bug.HumanID(childComplexity), true
  653
  654	case "Bug.id":
  655		if e.complexity.Bug.ID == nil {
  656			break
  657		}
  658
  659		return e.complexity.Bug.ID(childComplexity), true
  660
  661	case "Bug.labels":
  662		if e.complexity.Bug.Labels == nil {
  663			break
  664		}
  665
  666		return e.complexity.Bug.Labels(childComplexity), true
  667
  668	case "Bug.lastEdit":
  669		if e.complexity.Bug.LastEdit == nil {
  670			break
  671		}
  672
  673		return e.complexity.Bug.LastEdit(childComplexity), true
  674
  675	case "Bug.operations":
  676		if e.complexity.Bug.Operations == nil {
  677			break
  678		}
  679
  680		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  681		if err != nil {
  682			return 0, false
  683		}
  684
  685		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  686
  687	case "Bug.participants":
  688		if e.complexity.Bug.Participants == nil {
  689			break
  690		}
  691
  692		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  693		if err != nil {
  694			return 0, false
  695		}
  696
  697		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  698
  699	case "Bug.status":
  700		if e.complexity.Bug.Status == nil {
  701			break
  702		}
  703
  704		return e.complexity.Bug.Status(childComplexity), true
  705
  706	case "Bug.timeline":
  707		if e.complexity.Bug.Timeline == nil {
  708			break
  709		}
  710
  711		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  712		if err != nil {
  713			return 0, false
  714		}
  715
  716		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  717
  718	case "Bug.title":
  719		if e.complexity.Bug.Title == nil {
  720			break
  721		}
  722
  723		return e.complexity.Bug.Title(childComplexity), true
  724
  725	case "BugConnection.edges":
  726		if e.complexity.BugConnection.Edges == nil {
  727			break
  728		}
  729
  730		return e.complexity.BugConnection.Edges(childComplexity), true
  731
  732	case "BugConnection.nodes":
  733		if e.complexity.BugConnection.Nodes == nil {
  734			break
  735		}
  736
  737		return e.complexity.BugConnection.Nodes(childComplexity), true
  738
  739	case "BugConnection.pageInfo":
  740		if e.complexity.BugConnection.PageInfo == nil {
  741			break
  742		}
  743
  744		return e.complexity.BugConnection.PageInfo(childComplexity), true
  745
  746	case "BugConnection.totalCount":
  747		if e.complexity.BugConnection.TotalCount == nil {
  748			break
  749		}
  750
  751		return e.complexity.BugConnection.TotalCount(childComplexity), true
  752
  753	case "BugEdge.cursor":
  754		if e.complexity.BugEdge.Cursor == nil {
  755			break
  756		}
  757
  758		return e.complexity.BugEdge.Cursor(childComplexity), true
  759
  760	case "BugEdge.node":
  761		if e.complexity.BugEdge.Node == nil {
  762			break
  763		}
  764
  765		return e.complexity.BugEdge.Node(childComplexity), true
  766
  767	case "ChangeLabelPayload.bug":
  768		if e.complexity.ChangeLabelPayload.Bug == nil {
  769			break
  770		}
  771
  772		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  773
  774	case "ChangeLabelPayload.clientMutationId":
  775		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  776			break
  777		}
  778
  779		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  780
  781	case "ChangeLabelPayload.operation":
  782		if e.complexity.ChangeLabelPayload.Operation == nil {
  783			break
  784		}
  785
  786		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  787
  788	case "ChangeLabelPayload.results":
  789		if e.complexity.ChangeLabelPayload.Results == nil {
  790			break
  791		}
  792
  793		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  794
  795	case "CloseBugPayload.bug":
  796		if e.complexity.CloseBugPayload.Bug == nil {
  797			break
  798		}
  799
  800		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  801
  802	case "CloseBugPayload.clientMutationId":
  803		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  804			break
  805		}
  806
  807		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  808
  809	case "CloseBugPayload.operation":
  810		if e.complexity.CloseBugPayload.Operation == nil {
  811			break
  812		}
  813
  814		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  815
  816	case "Color.B":
  817		if e.complexity.Color.B == nil {
  818			break
  819		}
  820
  821		return e.complexity.Color.B(childComplexity), true
  822
  823	case "Color.G":
  824		if e.complexity.Color.G == nil {
  825			break
  826		}
  827
  828		return e.complexity.Color.G(childComplexity), true
  829
  830	case "Color.R":
  831		if e.complexity.Color.R == nil {
  832			break
  833		}
  834
  835		return e.complexity.Color.R(childComplexity), true
  836
  837	case "Comment.author":
  838		if e.complexity.Comment.Author == nil {
  839			break
  840		}
  841
  842		return e.complexity.Comment.Author(childComplexity), true
  843
  844	case "Comment.files":
  845		if e.complexity.Comment.Files == nil {
  846			break
  847		}
  848
  849		return e.complexity.Comment.Files(childComplexity), true
  850
  851	case "Comment.message":
  852		if e.complexity.Comment.Message == nil {
  853			break
  854		}
  855
  856		return e.complexity.Comment.Message(childComplexity), true
  857
  858	case "CommentConnection.edges":
  859		if e.complexity.CommentConnection.Edges == nil {
  860			break
  861		}
  862
  863		return e.complexity.CommentConnection.Edges(childComplexity), true
  864
  865	case "CommentConnection.nodes":
  866		if e.complexity.CommentConnection.Nodes == nil {
  867			break
  868		}
  869
  870		return e.complexity.CommentConnection.Nodes(childComplexity), true
  871
  872	case "CommentConnection.pageInfo":
  873		if e.complexity.CommentConnection.PageInfo == nil {
  874			break
  875		}
  876
  877		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  878
  879	case "CommentConnection.totalCount":
  880		if e.complexity.CommentConnection.TotalCount == nil {
  881			break
  882		}
  883
  884		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  885
  886	case "CommentEdge.cursor":
  887		if e.complexity.CommentEdge.Cursor == nil {
  888			break
  889		}
  890
  891		return e.complexity.CommentEdge.Cursor(childComplexity), true
  892
  893	case "CommentEdge.node":
  894		if e.complexity.CommentEdge.Node == nil {
  895			break
  896		}
  897
  898		return e.complexity.CommentEdge.Node(childComplexity), true
  899
  900	case "CommentHistoryStep.date":
  901		if e.complexity.CommentHistoryStep.Date == nil {
  902			break
  903		}
  904
  905		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  906
  907	case "CommentHistoryStep.message":
  908		if e.complexity.CommentHistoryStep.Message == nil {
  909			break
  910		}
  911
  912		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  913
  914	case "CreateOperation.author":
  915		if e.complexity.CreateOperation.Author == nil {
  916			break
  917		}
  918
  919		return e.complexity.CreateOperation.Author(childComplexity), true
  920
  921	case "CreateOperation.date":
  922		if e.complexity.CreateOperation.Date == nil {
  923			break
  924		}
  925
  926		return e.complexity.CreateOperation.Date(childComplexity), true
  927
  928	case "CreateOperation.files":
  929		if e.complexity.CreateOperation.Files == nil {
  930			break
  931		}
  932
  933		return e.complexity.CreateOperation.Files(childComplexity), true
  934
  935	case "CreateOperation.id":
  936		if e.complexity.CreateOperation.ID == nil {
  937			break
  938		}
  939
  940		return e.complexity.CreateOperation.ID(childComplexity), true
  941
  942	case "CreateOperation.message":
  943		if e.complexity.CreateOperation.Message == nil {
  944			break
  945		}
  946
  947		return e.complexity.CreateOperation.Message(childComplexity), true
  948
  949	case "CreateOperation.title":
  950		if e.complexity.CreateOperation.Title == nil {
  951			break
  952		}
  953
  954		return e.complexity.CreateOperation.Title(childComplexity), true
  955
  956	case "CreateTimelineItem.author":
  957		if e.complexity.CreateTimelineItem.Author == nil {
  958			break
  959		}
  960
  961		return e.complexity.CreateTimelineItem.Author(childComplexity), true
  962
  963	case "CreateTimelineItem.createdAt":
  964		if e.complexity.CreateTimelineItem.CreatedAt == nil {
  965			break
  966		}
  967
  968		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
  969
  970	case "CreateTimelineItem.edited":
  971		if e.complexity.CreateTimelineItem.Edited == nil {
  972			break
  973		}
  974
  975		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
  976
  977	case "CreateTimelineItem.files":
  978		if e.complexity.CreateTimelineItem.Files == nil {
  979			break
  980		}
  981
  982		return e.complexity.CreateTimelineItem.Files(childComplexity), true
  983
  984	case "CreateTimelineItem.history":
  985		if e.complexity.CreateTimelineItem.History == nil {
  986			break
  987		}
  988
  989		return e.complexity.CreateTimelineItem.History(childComplexity), true
  990
  991	case "CreateTimelineItem.id":
  992		if e.complexity.CreateTimelineItem.ID == nil {
  993			break
  994		}
  995
  996		return e.complexity.CreateTimelineItem.ID(childComplexity), true
  997
  998	case "CreateTimelineItem.lastEdit":
  999		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1000			break
 1001		}
 1002
 1003		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1004
 1005	case "CreateTimelineItem.message":
 1006		if e.complexity.CreateTimelineItem.Message == nil {
 1007			break
 1008		}
 1009
 1010		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1011
 1012	case "CreateTimelineItem.messageIsEmpty":
 1013		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1014			break
 1015		}
 1016
 1017		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1018
 1019	case "EditCommentOperation.author":
 1020		if e.complexity.EditCommentOperation.Author == nil {
 1021			break
 1022		}
 1023
 1024		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1025
 1026	case "EditCommentOperation.date":
 1027		if e.complexity.EditCommentOperation.Date == nil {
 1028			break
 1029		}
 1030
 1031		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1032
 1033	case "EditCommentOperation.files":
 1034		if e.complexity.EditCommentOperation.Files == nil {
 1035			break
 1036		}
 1037
 1038		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1039
 1040	case "EditCommentOperation.id":
 1041		if e.complexity.EditCommentOperation.ID == nil {
 1042			break
 1043		}
 1044
 1045		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1046
 1047	case "EditCommentOperation.message":
 1048		if e.complexity.EditCommentOperation.Message == nil {
 1049			break
 1050		}
 1051
 1052		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1053
 1054	case "EditCommentOperation.target":
 1055		if e.complexity.EditCommentOperation.Target == nil {
 1056			break
 1057		}
 1058
 1059		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1060
 1061	case "Identity.avatarUrl":
 1062		if e.complexity.Identity.AvatarUrl == nil {
 1063			break
 1064		}
 1065
 1066		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1067
 1068	case "Identity.displayName":
 1069		if e.complexity.Identity.DisplayName == nil {
 1070			break
 1071		}
 1072
 1073		return e.complexity.Identity.DisplayName(childComplexity), true
 1074
 1075	case "Identity.email":
 1076		if e.complexity.Identity.Email == nil {
 1077			break
 1078		}
 1079
 1080		return e.complexity.Identity.Email(childComplexity), true
 1081
 1082	case "Identity.humanId":
 1083		if e.complexity.Identity.HumanID == nil {
 1084			break
 1085		}
 1086
 1087		return e.complexity.Identity.HumanID(childComplexity), true
 1088
 1089	case "Identity.id":
 1090		if e.complexity.Identity.ID == nil {
 1091			break
 1092		}
 1093
 1094		return e.complexity.Identity.ID(childComplexity), true
 1095
 1096	case "Identity.isProtected":
 1097		if e.complexity.Identity.IsProtected == nil {
 1098			break
 1099		}
 1100
 1101		return e.complexity.Identity.IsProtected(childComplexity), true
 1102
 1103	case "Identity.name":
 1104		if e.complexity.Identity.Name == nil {
 1105			break
 1106		}
 1107
 1108		return e.complexity.Identity.Name(childComplexity), true
 1109
 1110	case "IdentityConnection.edges":
 1111		if e.complexity.IdentityConnection.Edges == nil {
 1112			break
 1113		}
 1114
 1115		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1116
 1117	case "IdentityConnection.nodes":
 1118		if e.complexity.IdentityConnection.Nodes == nil {
 1119			break
 1120		}
 1121
 1122		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1123
 1124	case "IdentityConnection.pageInfo":
 1125		if e.complexity.IdentityConnection.PageInfo == nil {
 1126			break
 1127		}
 1128
 1129		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1130
 1131	case "IdentityConnection.totalCount":
 1132		if e.complexity.IdentityConnection.TotalCount == nil {
 1133			break
 1134		}
 1135
 1136		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1137
 1138	case "IdentityEdge.cursor":
 1139		if e.complexity.IdentityEdge.Cursor == nil {
 1140			break
 1141		}
 1142
 1143		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1144
 1145	case "IdentityEdge.node":
 1146		if e.complexity.IdentityEdge.Node == nil {
 1147			break
 1148		}
 1149
 1150		return e.complexity.IdentityEdge.Node(childComplexity), true
 1151
 1152	case "Label.color":
 1153		if e.complexity.Label.Color == nil {
 1154			break
 1155		}
 1156
 1157		return e.complexity.Label.Color(childComplexity), true
 1158
 1159	case "Label.name":
 1160		if e.complexity.Label.Name == nil {
 1161			break
 1162		}
 1163
 1164		return e.complexity.Label.Name(childComplexity), true
 1165
 1166	case "LabelChangeOperation.added":
 1167		if e.complexity.LabelChangeOperation.Added == nil {
 1168			break
 1169		}
 1170
 1171		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1172
 1173	case "LabelChangeOperation.author":
 1174		if e.complexity.LabelChangeOperation.Author == nil {
 1175			break
 1176		}
 1177
 1178		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1179
 1180	case "LabelChangeOperation.date":
 1181		if e.complexity.LabelChangeOperation.Date == nil {
 1182			break
 1183		}
 1184
 1185		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1186
 1187	case "LabelChangeOperation.id":
 1188		if e.complexity.LabelChangeOperation.ID == nil {
 1189			break
 1190		}
 1191
 1192		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1193
 1194	case "LabelChangeOperation.removed":
 1195		if e.complexity.LabelChangeOperation.Removed == nil {
 1196			break
 1197		}
 1198
 1199		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1200
 1201	case "LabelChangeResult.label":
 1202		if e.complexity.LabelChangeResult.Label == nil {
 1203			break
 1204		}
 1205
 1206		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1207
 1208	case "LabelChangeResult.status":
 1209		if e.complexity.LabelChangeResult.Status == nil {
 1210			break
 1211		}
 1212
 1213		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1214
 1215	case "LabelChangeTimelineItem.added":
 1216		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1217			break
 1218		}
 1219
 1220		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1221
 1222	case "LabelChangeTimelineItem.author":
 1223		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1224			break
 1225		}
 1226
 1227		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1228
 1229	case "LabelChangeTimelineItem.date":
 1230		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1231			break
 1232		}
 1233
 1234		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1235
 1236	case "LabelChangeTimelineItem.id":
 1237		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1238			break
 1239		}
 1240
 1241		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1242
 1243	case "LabelChangeTimelineItem.removed":
 1244		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1245			break
 1246		}
 1247
 1248		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1249
 1250	case "LabelConnection.edges":
 1251		if e.complexity.LabelConnection.Edges == nil {
 1252			break
 1253		}
 1254
 1255		return e.complexity.LabelConnection.Edges(childComplexity), true
 1256
 1257	case "LabelConnection.nodes":
 1258		if e.complexity.LabelConnection.Nodes == nil {
 1259			break
 1260		}
 1261
 1262		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1263
 1264	case "LabelConnection.pageInfo":
 1265		if e.complexity.LabelConnection.PageInfo == nil {
 1266			break
 1267		}
 1268
 1269		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1270
 1271	case "LabelConnection.totalCount":
 1272		if e.complexity.LabelConnection.TotalCount == nil {
 1273			break
 1274		}
 1275
 1276		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1277
 1278	case "LabelEdge.cursor":
 1279		if e.complexity.LabelEdge.Cursor == nil {
 1280			break
 1281		}
 1282
 1283		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1284
 1285	case "LabelEdge.node":
 1286		if e.complexity.LabelEdge.Node == nil {
 1287			break
 1288		}
 1289
 1290		return e.complexity.LabelEdge.Node(childComplexity), true
 1291
 1292	case "Mutation.addComment":
 1293		if e.complexity.Mutation.AddComment == nil {
 1294			break
 1295		}
 1296
 1297		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1298		if err != nil {
 1299			return 0, false
 1300		}
 1301
 1302		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1303
 1304	case "Mutation.changeLabels":
 1305		if e.complexity.Mutation.ChangeLabels == nil {
 1306			break
 1307		}
 1308
 1309		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1310		if err != nil {
 1311			return 0, false
 1312		}
 1313
 1314		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1315
 1316	case "Mutation.closeBug":
 1317		if e.complexity.Mutation.CloseBug == nil {
 1318			break
 1319		}
 1320
 1321		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1322		if err != nil {
 1323			return 0, false
 1324		}
 1325
 1326		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1327
 1328	case "Mutation.newBug":
 1329		if e.complexity.Mutation.NewBug == nil {
 1330			break
 1331		}
 1332
 1333		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1334		if err != nil {
 1335			return 0, false
 1336		}
 1337
 1338		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1339
 1340	case "Mutation.openBug":
 1341		if e.complexity.Mutation.OpenBug == nil {
 1342			break
 1343		}
 1344
 1345		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1346		if err != nil {
 1347			return 0, false
 1348		}
 1349
 1350		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1351
 1352	case "Mutation.setTitle":
 1353		if e.complexity.Mutation.SetTitle == nil {
 1354			break
 1355		}
 1356
 1357		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1358		if err != nil {
 1359			return 0, false
 1360		}
 1361
 1362		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1363
 1364	case "NewBugPayload.bug":
 1365		if e.complexity.NewBugPayload.Bug == nil {
 1366			break
 1367		}
 1368
 1369		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1370
 1371	case "NewBugPayload.clientMutationId":
 1372		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1373			break
 1374		}
 1375
 1376		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1377
 1378	case "NewBugPayload.operation":
 1379		if e.complexity.NewBugPayload.Operation == nil {
 1380			break
 1381		}
 1382
 1383		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1384
 1385	case "OpenBugPayload.bug":
 1386		if e.complexity.OpenBugPayload.Bug == nil {
 1387			break
 1388		}
 1389
 1390		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1391
 1392	case "OpenBugPayload.clientMutationId":
 1393		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1394			break
 1395		}
 1396
 1397		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1398
 1399	case "OpenBugPayload.operation":
 1400		if e.complexity.OpenBugPayload.Operation == nil {
 1401			break
 1402		}
 1403
 1404		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1405
 1406	case "OperationConnection.edges":
 1407		if e.complexity.OperationConnection.Edges == nil {
 1408			break
 1409		}
 1410
 1411		return e.complexity.OperationConnection.Edges(childComplexity), true
 1412
 1413	case "OperationConnection.nodes":
 1414		if e.complexity.OperationConnection.Nodes == nil {
 1415			break
 1416		}
 1417
 1418		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1419
 1420	case "OperationConnection.pageInfo":
 1421		if e.complexity.OperationConnection.PageInfo == nil {
 1422			break
 1423		}
 1424
 1425		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1426
 1427	case "OperationConnection.totalCount":
 1428		if e.complexity.OperationConnection.TotalCount == nil {
 1429			break
 1430		}
 1431
 1432		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1433
 1434	case "OperationEdge.cursor":
 1435		if e.complexity.OperationEdge.Cursor == nil {
 1436			break
 1437		}
 1438
 1439		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1440
 1441	case "OperationEdge.node":
 1442		if e.complexity.OperationEdge.Node == nil {
 1443			break
 1444		}
 1445
 1446		return e.complexity.OperationEdge.Node(childComplexity), true
 1447
 1448	case "PageInfo.endCursor":
 1449		if e.complexity.PageInfo.EndCursor == nil {
 1450			break
 1451		}
 1452
 1453		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1454
 1455	case "PageInfo.hasNextPage":
 1456		if e.complexity.PageInfo.HasNextPage == nil {
 1457			break
 1458		}
 1459
 1460		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1461
 1462	case "PageInfo.hasPreviousPage":
 1463		if e.complexity.PageInfo.HasPreviousPage == nil {
 1464			break
 1465		}
 1466
 1467		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1468
 1469	case "PageInfo.startCursor":
 1470		if e.complexity.PageInfo.StartCursor == nil {
 1471			break
 1472		}
 1473
 1474		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1475
 1476	case "Query.repository":
 1477		if e.complexity.Query.Repository == nil {
 1478			break
 1479		}
 1480
 1481		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1482		if err != nil {
 1483			return 0, false
 1484		}
 1485
 1486		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 1487
 1488	case "Repository.allBugs":
 1489		if e.complexity.Repository.AllBugs == nil {
 1490			break
 1491		}
 1492
 1493		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1494		if err != nil {
 1495			return 0, false
 1496		}
 1497
 1498		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1499
 1500	case "Repository.allIdentities":
 1501		if e.complexity.Repository.AllIdentities == nil {
 1502			break
 1503		}
 1504
 1505		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1506		if err != nil {
 1507			return 0, false
 1508		}
 1509
 1510		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1511
 1512	case "Repository.bug":
 1513		if e.complexity.Repository.Bug == nil {
 1514			break
 1515		}
 1516
 1517		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1518		if err != nil {
 1519			return 0, false
 1520		}
 1521
 1522		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1523
 1524	case "Repository.identity":
 1525		if e.complexity.Repository.Identity == nil {
 1526			break
 1527		}
 1528
 1529		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1530		if err != nil {
 1531			return 0, false
 1532		}
 1533
 1534		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1535
 1536	case "Repository.name":
 1537		if e.complexity.Repository.Name == nil {
 1538			break
 1539		}
 1540
 1541		return e.complexity.Repository.Name(childComplexity), true
 1542
 1543	case "Repository.userIdentity":
 1544		if e.complexity.Repository.UserIdentity == nil {
 1545			break
 1546		}
 1547
 1548		return e.complexity.Repository.UserIdentity(childComplexity), true
 1549
 1550	case "Repository.validLabels":
 1551		if e.complexity.Repository.ValidLabels == nil {
 1552			break
 1553		}
 1554
 1555		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1556		if err != nil {
 1557			return 0, false
 1558		}
 1559
 1560		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1561
 1562	case "SetStatusOperation.author":
 1563		if e.complexity.SetStatusOperation.Author == nil {
 1564			break
 1565		}
 1566
 1567		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1568
 1569	case "SetStatusOperation.date":
 1570		if e.complexity.SetStatusOperation.Date == nil {
 1571			break
 1572		}
 1573
 1574		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1575
 1576	case "SetStatusOperation.id":
 1577		if e.complexity.SetStatusOperation.ID == nil {
 1578			break
 1579		}
 1580
 1581		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1582
 1583	case "SetStatusOperation.status":
 1584		if e.complexity.SetStatusOperation.Status == nil {
 1585			break
 1586		}
 1587
 1588		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1589
 1590	case "SetStatusTimelineItem.author":
 1591		if e.complexity.SetStatusTimelineItem.Author == nil {
 1592			break
 1593		}
 1594
 1595		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1596
 1597	case "SetStatusTimelineItem.date":
 1598		if e.complexity.SetStatusTimelineItem.Date == nil {
 1599			break
 1600		}
 1601
 1602		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1603
 1604	case "SetStatusTimelineItem.id":
 1605		if e.complexity.SetStatusTimelineItem.ID == nil {
 1606			break
 1607		}
 1608
 1609		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1610
 1611	case "SetStatusTimelineItem.status":
 1612		if e.complexity.SetStatusTimelineItem.Status == nil {
 1613			break
 1614		}
 1615
 1616		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1617
 1618	case "SetTitleOperation.author":
 1619		if e.complexity.SetTitleOperation.Author == nil {
 1620			break
 1621		}
 1622
 1623		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1624
 1625	case "SetTitleOperation.date":
 1626		if e.complexity.SetTitleOperation.Date == nil {
 1627			break
 1628		}
 1629
 1630		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1631
 1632	case "SetTitleOperation.id":
 1633		if e.complexity.SetTitleOperation.ID == nil {
 1634			break
 1635		}
 1636
 1637		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1638
 1639	case "SetTitleOperation.title":
 1640		if e.complexity.SetTitleOperation.Title == nil {
 1641			break
 1642		}
 1643
 1644		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1645
 1646	case "SetTitleOperation.was":
 1647		if e.complexity.SetTitleOperation.Was == nil {
 1648			break
 1649		}
 1650
 1651		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1652
 1653	case "SetTitlePayload.bug":
 1654		if e.complexity.SetTitlePayload.Bug == nil {
 1655			break
 1656		}
 1657
 1658		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1659
 1660	case "SetTitlePayload.clientMutationId":
 1661		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1662			break
 1663		}
 1664
 1665		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1666
 1667	case "SetTitlePayload.operation":
 1668		if e.complexity.SetTitlePayload.Operation == nil {
 1669			break
 1670		}
 1671
 1672		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1673
 1674	case "SetTitleTimelineItem.author":
 1675		if e.complexity.SetTitleTimelineItem.Author == nil {
 1676			break
 1677		}
 1678
 1679		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1680
 1681	case "SetTitleTimelineItem.date":
 1682		if e.complexity.SetTitleTimelineItem.Date == nil {
 1683			break
 1684		}
 1685
 1686		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1687
 1688	case "SetTitleTimelineItem.id":
 1689		if e.complexity.SetTitleTimelineItem.ID == nil {
 1690			break
 1691		}
 1692
 1693		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1694
 1695	case "SetTitleTimelineItem.title":
 1696		if e.complexity.SetTitleTimelineItem.Title == nil {
 1697			break
 1698		}
 1699
 1700		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1701
 1702	case "SetTitleTimelineItem.was":
 1703		if e.complexity.SetTitleTimelineItem.Was == nil {
 1704			break
 1705		}
 1706
 1707		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1708
 1709	case "TimelineItemConnection.edges":
 1710		if e.complexity.TimelineItemConnection.Edges == nil {
 1711			break
 1712		}
 1713
 1714		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1715
 1716	case "TimelineItemConnection.nodes":
 1717		if e.complexity.TimelineItemConnection.Nodes == nil {
 1718			break
 1719		}
 1720
 1721		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1722
 1723	case "TimelineItemConnection.pageInfo":
 1724		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1725			break
 1726		}
 1727
 1728		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1729
 1730	case "TimelineItemConnection.totalCount":
 1731		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1732			break
 1733		}
 1734
 1735		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1736
 1737	case "TimelineItemEdge.cursor":
 1738		if e.complexity.TimelineItemEdge.Cursor == nil {
 1739			break
 1740		}
 1741
 1742		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1743
 1744	case "TimelineItemEdge.node":
 1745		if e.complexity.TimelineItemEdge.Node == nil {
 1746			break
 1747		}
 1748
 1749		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1750
 1751	}
 1752	return 0, false
 1753}
 1754
 1755func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1756	rc := graphql.GetOperationContext(ctx)
 1757	ec := executionContext{rc, e}
 1758	first := true
 1759
 1760	switch rc.Operation.Operation {
 1761	case ast.Query:
 1762		return func(ctx context.Context) *graphql.Response {
 1763			if !first {
 1764				return nil
 1765			}
 1766			first = false
 1767			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1768			var buf bytes.Buffer
 1769			data.MarshalGQL(&buf)
 1770
 1771			return &graphql.Response{
 1772				Data: buf.Bytes(),
 1773			}
 1774		}
 1775	case ast.Mutation:
 1776		return func(ctx context.Context) *graphql.Response {
 1777			if !first {
 1778				return nil
 1779			}
 1780			first = false
 1781			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1782			var buf bytes.Buffer
 1783			data.MarshalGQL(&buf)
 1784
 1785			return &graphql.Response{
 1786				Data: buf.Bytes(),
 1787			}
 1788		}
 1789
 1790	default:
 1791		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1792	}
 1793}
 1794
 1795type executionContext struct {
 1796	*graphql.OperationContext
 1797	*executableSchema
 1798}
 1799
 1800func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1801	if ec.DisableIntrospection {
 1802		return nil, errors.New("introspection disabled")
 1803	}
 1804	return introspection.WrapSchema(parsedSchema), nil
 1805}
 1806
 1807func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1808	if ec.DisableIntrospection {
 1809		return nil, errors.New("introspection disabled")
 1810	}
 1811	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1812}
 1813
 1814var sources = []*ast.Source{
 1815	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1816type Comment implements Authored {
 1817  """The author of this comment."""
 1818  author: Identity!
 1819
 1820  """The message of this comment."""
 1821  message: String!
 1822
 1823  """All media's hash referenced in this comment"""
 1824  files: [Hash!]!
 1825}
 1826
 1827type CommentConnection {
 1828  edges: [CommentEdge!]!
 1829  nodes: [Comment!]!
 1830  pageInfo: PageInfo!
 1831  totalCount: Int!
 1832}
 1833
 1834type CommentEdge {
 1835  cursor: String!
 1836  node: Comment!
 1837}
 1838
 1839enum Status {
 1840  OPEN
 1841  CLOSED
 1842}
 1843
 1844type Bug implements Authored {
 1845  """The identifier for this bug"""
 1846  id: String!
 1847  """The human version (truncated) identifier for this bug"""
 1848  humanId: String!
 1849  status: Status!
 1850  title: String!
 1851  labels: [Label!]!
 1852  author: Identity!
 1853  createdAt: Time!
 1854  lastEdit: Time!
 1855
 1856  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1857  actors(
 1858    """Returns the elements in the list that come after the specified cursor."""
 1859    after: String
 1860    """Returns the elements in the list that come before the specified cursor."""
 1861    before: String
 1862    """Returns the first _n_ elements from the list."""
 1863    first: Int
 1864    """Returns the last _n_ elements from the list."""
 1865    last: Int
 1866  ): IdentityConnection!
 1867
 1868  """The participants of the bug. Participants are Identity that have created or
 1869  added a comment on the bug."""
 1870  participants(
 1871    """Returns the elements in the list that come after the specified cursor."""
 1872    after: String
 1873    """Returns the elements in the list that come before the specified cursor."""
 1874    before: String
 1875    """Returns the first _n_ elements from the list."""
 1876    first: Int
 1877    """Returns the last _n_ elements from the list."""
 1878    last: Int
 1879  ): IdentityConnection!
 1880
 1881  comments(
 1882    """Returns the elements in the list that come after the specified cursor."""
 1883    after: String
 1884    """Returns the elements in the list that come before the specified cursor."""
 1885    before: String
 1886    """Returns the first _n_ elements from the list."""
 1887    first: Int
 1888    """Returns the last _n_ elements from the list."""
 1889    last: Int
 1890  ): CommentConnection!
 1891
 1892  timeline(
 1893    """Returns the elements in the list that come after the specified cursor."""
 1894    after: String
 1895    """Returns the elements in the list that come before the specified cursor."""
 1896    before: String
 1897    """Returns the first _n_ elements from the list."""
 1898    first: Int
 1899    """Returns the last _n_ elements from the list."""
 1900    last: Int
 1901  ): TimelineItemConnection!
 1902
 1903  operations(
 1904    """Returns the elements in the list that come after the specified cursor."""
 1905    after: String
 1906    """Returns the elements in the list that come before the specified cursor."""
 1907    before: String
 1908    """Returns the first _n_ elements from the list."""
 1909    first: Int
 1910    """Returns the last _n_ elements from the list."""
 1911    last: Int
 1912  ): OperationConnection!
 1913}
 1914
 1915"""The connection type for Bug."""
 1916type BugConnection {
 1917  """A list of edges."""
 1918  edges: [BugEdge!]!
 1919  nodes: [Bug!]!
 1920  """Information to aid in pagination."""
 1921  pageInfo: PageInfo!
 1922  """Identifies the total count of items in the connection."""
 1923  totalCount: Int!
 1924}
 1925
 1926"""An edge in a connection."""
 1927type BugEdge {
 1928  """A cursor for use in pagination."""
 1929  cursor: String!
 1930  """The item at the end of the edge."""
 1931  node: Bug!
 1932}
 1933`, BuiltIn: false},
 1934	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1935type Identity {
 1936    """The identifier for this identity"""
 1937    id: String!
 1938    """The human version (truncated) identifier for this identity"""
 1939    humanId: String!
 1940    """The name of the person, if known."""
 1941    name: String
 1942    """The email of the person, if known."""
 1943    email: String
 1944    """A non-empty string to display, representing the identity, based on the non-empty values."""
 1945    displayName: String!
 1946    """An url to an avatar"""
 1947    avatarUrl: String
 1948    """isProtected is true if the chain of git commits started to be signed.
 1949    If that's the case, only signed commit with a valid key for this identity can be added."""
 1950    isProtected: Boolean!
 1951}
 1952
 1953type IdentityConnection {
 1954    edges: [IdentityEdge!]!
 1955    nodes: [Identity!]!
 1956    pageInfo: PageInfo!
 1957    totalCount: Int!
 1958}
 1959
 1960type IdentityEdge {
 1961    cursor: String!
 1962    node: Identity!
 1963}`, BuiltIn: false},
 1964	&ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
 1965type Label {
 1966    """The name of the label."""
 1967    name: String!
 1968    """Color of the label."""
 1969    color: Color!
 1970}
 1971
 1972type LabelConnection {
 1973    edges: [LabelEdge!]!
 1974    nodes: [Label!]!
 1975    pageInfo: PageInfo!
 1976    totalCount: Int!
 1977}
 1978
 1979type LabelEdge {
 1980    cursor: String!
 1981    node: Label!
 1982}`, BuiltIn: false},
 1983	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 1984    """A unique identifier for the client performing the mutation."""
 1985    clientMutationId: String
 1986    """"The name of the repository. If not set, the default repository is used."""
 1987    repoRef: String
 1988    """The title of the new bug."""
 1989    title: String!
 1990    """The first message of the new bug."""
 1991    message: String!
 1992    """The collection of file's hash required for the first message."""
 1993    files: [Hash!]
 1994}
 1995
 1996type NewBugPayload {
 1997    """A unique identifier for the client performing the mutation."""
 1998    clientMutationId: String
 1999    """The created bug."""
 2000    bug: Bug!
 2001    """The resulting operation."""
 2002    operation: CreateOperation!
 2003}
 2004
 2005input AddCommentInput {
 2006    """A unique identifier for the client performing the mutation."""
 2007    clientMutationId: String
 2008    """"The name of the repository. If not set, the default repository is used."""
 2009    repoRef: String
 2010    """The bug ID's prefix."""
 2011    prefix: String!
 2012    """The first message of the new bug."""
 2013    message: String!
 2014    """The collection of file's hash required for the first message."""
 2015    files: [Hash!]
 2016}
 2017
 2018type AddCommentPayload {
 2019    """A unique identifier for the client performing the mutation."""
 2020    clientMutationId: String
 2021    """The affected bug."""
 2022    bug: Bug!
 2023    """The resulting operation."""
 2024    operation: AddCommentOperation!
 2025}
 2026
 2027input ChangeLabelInput {
 2028    """A unique identifier for the client performing the mutation."""
 2029    clientMutationId: String
 2030    """"The name of the repository. If not set, the default repository is used."""
 2031    repoRef: String
 2032    """The bug ID's prefix."""
 2033    prefix: String!
 2034    """The list of label to add."""
 2035    added: [String!]
 2036    """The list of label to remove."""
 2037    Removed: [String!]
 2038}
 2039
 2040enum LabelChangeStatus {
 2041    ADDED
 2042    REMOVED
 2043    DUPLICATE_IN_OP
 2044    ALREADY_EXIST
 2045    DOESNT_EXIST
 2046}
 2047
 2048type LabelChangeResult {
 2049    """The source label."""
 2050    label: Label!
 2051    """The effect this label had."""
 2052    status: LabelChangeStatus!
 2053}
 2054
 2055type ChangeLabelPayload {
 2056    """A unique identifier for the client performing the mutation."""
 2057    clientMutationId: String
 2058    """The affected bug."""
 2059    bug: Bug!
 2060    """The resulting operation."""
 2061    operation: LabelChangeOperation!
 2062    """The effect each source label had."""
 2063    results: [LabelChangeResult]!
 2064}
 2065
 2066input OpenBugInput {
 2067    """A unique identifier for the client performing the mutation."""
 2068    clientMutationId: String
 2069    """"The name of the repository. If not set, the default repository is used."""
 2070    repoRef: String
 2071    """The bug ID's prefix."""
 2072    prefix: String!
 2073}
 2074
 2075type OpenBugPayload {
 2076    """A unique identifier for the client performing the mutation."""
 2077    clientMutationId: String
 2078    """The affected bug."""
 2079    bug: Bug!
 2080    """The resulting operation."""
 2081    operation: SetStatusOperation!
 2082}
 2083
 2084input CloseBugInput {
 2085    """A unique identifier for the client performing the mutation."""
 2086    clientMutationId: String
 2087    """"The name of the repository. If not set, the default repository is used."""
 2088    repoRef: String
 2089    """The bug ID's prefix."""
 2090    prefix: String!
 2091}
 2092
 2093type CloseBugPayload {
 2094    """A unique identifier for the client performing the mutation."""
 2095    clientMutationId: String
 2096    """The affected bug."""
 2097    bug: Bug!
 2098    """The resulting operation."""
 2099    operation: SetStatusOperation!
 2100}
 2101
 2102input SetTitleInput {
 2103    """A unique identifier for the client performing the mutation."""
 2104    clientMutationId: String
 2105    """"The name of the repository. If not set, the default repository is used."""
 2106    repoRef: String
 2107    """The bug ID's prefix."""
 2108    prefix: String!
 2109    """The new title."""
 2110    title: String!
 2111}
 2112
 2113type SetTitlePayload {
 2114    """A unique identifier for the client performing the mutation."""
 2115    clientMutationId: String
 2116    """The affected bug."""
 2117    bug: Bug!
 2118    """The resulting operation"""
 2119    operation: SetTitleOperation!
 2120}
 2121`, BuiltIn: false},
 2122	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2123interface Operation {
 2124    """The identifier of the operation"""
 2125    id: String!
 2126    """The operations author."""
 2127    author: Identity!
 2128    """The datetime when this operation was issued."""
 2129    date: Time!
 2130}
 2131
 2132# Connection
 2133
 2134"""The connection type for an Operation"""
 2135type OperationConnection {
 2136    edges: [OperationEdge!]!
 2137    nodes: [Operation!]!
 2138    pageInfo: PageInfo!
 2139    totalCount: Int!
 2140}
 2141
 2142"""Represent an Operation"""
 2143type OperationEdge {
 2144    cursor: String!
 2145    node: Operation!
 2146}
 2147
 2148# Operations
 2149
 2150type CreateOperation implements Operation & Authored {
 2151    """The identifier of the operation"""
 2152    id: String!
 2153    """The author of this object."""
 2154    author: Identity!
 2155    """The datetime when this operation was issued."""
 2156    date: Time!
 2157
 2158    title: String!
 2159    message: String!
 2160    files: [Hash!]!
 2161}
 2162
 2163type SetTitleOperation implements Operation & Authored {
 2164    """The identifier of the operation"""
 2165    id: String!
 2166    """The author of this object."""
 2167    author: Identity!
 2168    """The datetime when this operation was issued."""
 2169    date: Time!
 2170
 2171    title: String!
 2172    was: String!
 2173}
 2174
 2175type AddCommentOperation implements Operation & Authored {
 2176    """The identifier of the operation"""
 2177    id: String!
 2178    """The author of this object."""
 2179    author: Identity!
 2180    """The datetime when this operation was issued."""
 2181    date: Time!
 2182
 2183    message: String!
 2184    files: [Hash!]!
 2185}
 2186
 2187type EditCommentOperation implements Operation & Authored {
 2188    """The identifier of the operation"""
 2189    id: String!
 2190    """The author of this object."""
 2191    author: Identity!
 2192    """The datetime when this operation was issued."""
 2193    date: Time!
 2194
 2195    target: String!
 2196    message: String!
 2197    files: [Hash!]!
 2198}
 2199
 2200type SetStatusOperation implements Operation & Authored {
 2201    """The identifier of the operation"""
 2202    id: String!
 2203    """The author of this object."""
 2204    author: Identity!
 2205    """The datetime when this operation was issued."""
 2206    date: Time!
 2207
 2208    status: Status!
 2209}
 2210
 2211type LabelChangeOperation 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    added: [Label!]!
 2220    removed: [Label!]!
 2221}
 2222`, BuiltIn: false},
 2223	&ast.Source{Name: "schema/repository.graphql", Input: `
 2224type Repository {
 2225    """The name of the repository"""
 2226    name: String
 2227
 2228    """All the bugs"""
 2229    allBugs(
 2230        """Returns the elements in the list that come after the specified cursor."""
 2231        after: String
 2232        """Returns the elements in the list that come before the specified cursor."""
 2233        before: String
 2234        """Returns the first _n_ elements from the list."""
 2235        first: Int
 2236        """Returns the last _n_ elements from the list."""
 2237        last: Int
 2238        """A query to select and order bugs."""
 2239        query: String
 2240    ): BugConnection!
 2241
 2242    bug(prefix: String!): Bug
 2243
 2244    """All the identities"""
 2245    allIdentities(
 2246        """Returns the elements in the list that come after the specified cursor."""
 2247        after: String
 2248        """Returns the elements in the list that come before the specified cursor."""
 2249        before: String
 2250        """Returns the first _n_ elements from the list."""
 2251        first: Int
 2252        """Returns the last _n_ elements from the list."""
 2253        last: Int
 2254    ): IdentityConnection!
 2255
 2256    identity(prefix: String!): Identity
 2257
 2258    """The identity created or selected by the user as its own"""
 2259    userIdentity: Identity
 2260
 2261    """List of valid labels."""
 2262    validLabels(
 2263        """Returns the elements in the list that come after the specified cursor."""
 2264        after: String
 2265        """Returns the elements in the list that come before the specified cursor."""
 2266        before: String
 2267        """Returns the first _n_ elements from the list."""
 2268        first: Int
 2269        """Returns the last _n_ elements from the list."""
 2270        last: Int
 2271    ): LabelConnection!
 2272}`, BuiltIn: false},
 2273	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2274    """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
 2275    repository(ref: String): Repository
 2276}
 2277
 2278type Mutation {
 2279    """Create a new bug"""
 2280    newBug(input: NewBugInput!): NewBugPayload!
 2281    """Add a new comment to a bug"""
 2282    addComment(input: AddCommentInput!): AddCommentPayload!
 2283    """Add or remove a set of label on a bug"""
 2284    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2285    """Change a bug's status to open"""
 2286    openBug(input: OpenBugInput!): OpenBugPayload!
 2287    """Change a bug's status to closed"""
 2288    closeBug(input: CloseBugInput!): CloseBugPayload!
 2289    """Change a bug's title"""
 2290    setTitle(input: SetTitleInput!): SetTitlePayload!
 2291}
 2292`, BuiltIn: false},
 2293	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2294interface TimelineItem {
 2295    """The identifier of the source operation"""
 2296    id: String!
 2297}
 2298
 2299"""CommentHistoryStep hold one version of a message in the history"""
 2300type CommentHistoryStep {
 2301    message: String!
 2302    date: Time!
 2303}
 2304
 2305# Connection
 2306
 2307"""The connection type for TimelineItem"""
 2308type TimelineItemConnection {
 2309    edges: [TimelineItemEdge!]!
 2310    nodes: [TimelineItem!]!
 2311    pageInfo: PageInfo!
 2312    totalCount: Int!
 2313}
 2314
 2315"""Represent a TimelineItem"""
 2316type TimelineItemEdge {
 2317    cursor: String!
 2318    node: TimelineItem!
 2319}
 2320
 2321# Items
 2322
 2323"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2324type CreateTimelineItem implements TimelineItem & Authored {
 2325    """The identifier of the source operation"""
 2326    id: String!
 2327    author: Identity!
 2328    message: String!
 2329    messageIsEmpty: Boolean!
 2330    files: [Hash!]!
 2331    createdAt: Time!
 2332    lastEdit: Time!
 2333    edited: Boolean!
 2334    history: [CommentHistoryStep!]!
 2335}
 2336
 2337"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2338type AddCommentTimelineItem implements TimelineItem & Authored {
 2339    """The identifier of the source operation"""
 2340    id: String!
 2341    author: Identity!
 2342    message: String!
 2343    messageIsEmpty: Boolean!
 2344    files: [Hash!]!
 2345    createdAt: Time!
 2346    lastEdit: Time!
 2347    edited: Boolean!
 2348    history: [CommentHistoryStep!]!
 2349}
 2350
 2351"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2352type LabelChangeTimelineItem implements TimelineItem & Authored {
 2353    """The identifier of the source operation"""
 2354    id: String!
 2355    author: Identity!
 2356    date: Time!
 2357    added: [Label!]!
 2358    removed: [Label!]!
 2359}
 2360
 2361"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2362type SetStatusTimelineItem implements TimelineItem & Authored {
 2363    """The identifier of the source operation"""
 2364    id: String!
 2365    author: Identity!
 2366    date: Time!
 2367    status: Status!
 2368}
 2369
 2370"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2371type SetTitleTimelineItem implements TimelineItem & Authored {
 2372    """The identifier of the source operation"""
 2373    id: String!
 2374    author: Identity!
 2375    date: Time!
 2376    title: String!
 2377    was: String!
 2378}
 2379`, BuiltIn: false},
 2380	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2381scalar Hash
 2382
 2383"""Defines a color by red, green and blue components."""
 2384type Color {
 2385    """Red component of the color."""
 2386    R: Int!
 2387    """Green component of the color."""
 2388    G: Int!
 2389    """Blue component of the color."""
 2390    B: Int!
 2391}
 2392
 2393"""Information about pagination in a connection."""
 2394type PageInfo {
 2395    """When paginating forwards, are there more items?"""
 2396    hasNextPage: Boolean!
 2397    """When paginating backwards, are there more items?"""
 2398    hasPreviousPage: Boolean!
 2399    """When paginating backwards, the cursor to continue."""
 2400    startCursor: String!
 2401    """When paginating forwards, the cursor to continue."""
 2402    endCursor: String!
 2403}
 2404
 2405"""An object that has an author."""
 2406interface Authored {
 2407    """The author of this object."""
 2408    author: Identity!
 2409}
 2410`, BuiltIn: false},
 2411}
 2412var parsedSchema = gqlparser.MustLoadSchema(sources...)
 2413
 2414// endregion ************************** generated!.gotpl **************************
 2415
 2416// region    ***************************** args.gotpl *****************************
 2417
 2418func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2419	var err error
 2420	args := map[string]interface{}{}
 2421	var arg0 *string
 2422	if tmp, ok := rawArgs["after"]; ok {
 2423		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2424		if err != nil {
 2425			return nil, err
 2426		}
 2427	}
 2428	args["after"] = arg0
 2429	var arg1 *string
 2430	if tmp, ok := rawArgs["before"]; ok {
 2431		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2432		if err != nil {
 2433			return nil, err
 2434		}
 2435	}
 2436	args["before"] = arg1
 2437	var arg2 *int
 2438	if tmp, ok := rawArgs["first"]; ok {
 2439		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2440		if err != nil {
 2441			return nil, err
 2442		}
 2443	}
 2444	args["first"] = arg2
 2445	var arg3 *int
 2446	if tmp, ok := rawArgs["last"]; ok {
 2447		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2448		if err != nil {
 2449			return nil, err
 2450		}
 2451	}
 2452	args["last"] = arg3
 2453	return args, nil
 2454}
 2455
 2456func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2457	var err error
 2458	args := map[string]interface{}{}
 2459	var arg0 *string
 2460	if tmp, ok := rawArgs["after"]; ok {
 2461		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2462		if err != nil {
 2463			return nil, err
 2464		}
 2465	}
 2466	args["after"] = arg0
 2467	var arg1 *string
 2468	if tmp, ok := rawArgs["before"]; ok {
 2469		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2470		if err != nil {
 2471			return nil, err
 2472		}
 2473	}
 2474	args["before"] = arg1
 2475	var arg2 *int
 2476	if tmp, ok := rawArgs["first"]; ok {
 2477		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2478		if err != nil {
 2479			return nil, err
 2480		}
 2481	}
 2482	args["first"] = arg2
 2483	var arg3 *int
 2484	if tmp, ok := rawArgs["last"]; ok {
 2485		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2486		if err != nil {
 2487			return nil, err
 2488		}
 2489	}
 2490	args["last"] = arg3
 2491	return args, nil
 2492}
 2493
 2494func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2495	var err error
 2496	args := map[string]interface{}{}
 2497	var arg0 *string
 2498	if tmp, ok := rawArgs["after"]; ok {
 2499		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2500		if err != nil {
 2501			return nil, err
 2502		}
 2503	}
 2504	args["after"] = arg0
 2505	var arg1 *string
 2506	if tmp, ok := rawArgs["before"]; ok {
 2507		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2508		if err != nil {
 2509			return nil, err
 2510		}
 2511	}
 2512	args["before"] = arg1
 2513	var arg2 *int
 2514	if tmp, ok := rawArgs["first"]; ok {
 2515		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2516		if err != nil {
 2517			return nil, err
 2518		}
 2519	}
 2520	args["first"] = arg2
 2521	var arg3 *int
 2522	if tmp, ok := rawArgs["last"]; ok {
 2523		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2524		if err != nil {
 2525			return nil, err
 2526		}
 2527	}
 2528	args["last"] = arg3
 2529	return args, nil
 2530}
 2531
 2532func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2533	var err error
 2534	args := map[string]interface{}{}
 2535	var arg0 *string
 2536	if tmp, ok := rawArgs["after"]; ok {
 2537		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2538		if err != nil {
 2539			return nil, err
 2540		}
 2541	}
 2542	args["after"] = arg0
 2543	var arg1 *string
 2544	if tmp, ok := rawArgs["before"]; ok {
 2545		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2546		if err != nil {
 2547			return nil, err
 2548		}
 2549	}
 2550	args["before"] = arg1
 2551	var arg2 *int
 2552	if tmp, ok := rawArgs["first"]; ok {
 2553		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2554		if err != nil {
 2555			return nil, err
 2556		}
 2557	}
 2558	args["first"] = arg2
 2559	var arg3 *int
 2560	if tmp, ok := rawArgs["last"]; ok {
 2561		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2562		if err != nil {
 2563			return nil, err
 2564		}
 2565	}
 2566	args["last"] = arg3
 2567	return args, nil
 2568}
 2569
 2570func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2571	var err error
 2572	args := map[string]interface{}{}
 2573	var arg0 *string
 2574	if tmp, ok := rawArgs["after"]; ok {
 2575		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2576		if err != nil {
 2577			return nil, err
 2578		}
 2579	}
 2580	args["after"] = arg0
 2581	var arg1 *string
 2582	if tmp, ok := rawArgs["before"]; ok {
 2583		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2584		if err != nil {
 2585			return nil, err
 2586		}
 2587	}
 2588	args["before"] = arg1
 2589	var arg2 *int
 2590	if tmp, ok := rawArgs["first"]; ok {
 2591		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2592		if err != nil {
 2593			return nil, err
 2594		}
 2595	}
 2596	args["first"] = arg2
 2597	var arg3 *int
 2598	if tmp, ok := rawArgs["last"]; ok {
 2599		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2600		if err != nil {
 2601			return nil, err
 2602		}
 2603	}
 2604	args["last"] = arg3
 2605	return args, nil
 2606}
 2607
 2608func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2609	var err error
 2610	args := map[string]interface{}{}
 2611	var arg0 models.AddCommentInput
 2612	if tmp, ok := rawArgs["input"]; ok {
 2613		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2614		if err != nil {
 2615			return nil, err
 2616		}
 2617	}
 2618	args["input"] = arg0
 2619	return args, nil
 2620}
 2621
 2622func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2623	var err error
 2624	args := map[string]interface{}{}
 2625	var arg0 *models.ChangeLabelInput
 2626	if tmp, ok := rawArgs["input"]; ok {
 2627		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2628		if err != nil {
 2629			return nil, err
 2630		}
 2631	}
 2632	args["input"] = arg0
 2633	return args, nil
 2634}
 2635
 2636func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2637	var err error
 2638	args := map[string]interface{}{}
 2639	var arg0 models.CloseBugInput
 2640	if tmp, ok := rawArgs["input"]; ok {
 2641		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2642		if err != nil {
 2643			return nil, err
 2644		}
 2645	}
 2646	args["input"] = arg0
 2647	return args, nil
 2648}
 2649
 2650func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2651	var err error
 2652	args := map[string]interface{}{}
 2653	var arg0 models.NewBugInput
 2654	if tmp, ok := rawArgs["input"]; ok {
 2655		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2656		if err != nil {
 2657			return nil, err
 2658		}
 2659	}
 2660	args["input"] = arg0
 2661	return args, nil
 2662}
 2663
 2664func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2665	var err error
 2666	args := map[string]interface{}{}
 2667	var arg0 models.OpenBugInput
 2668	if tmp, ok := rawArgs["input"]; ok {
 2669		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2670		if err != nil {
 2671			return nil, err
 2672		}
 2673	}
 2674	args["input"] = arg0
 2675	return args, nil
 2676}
 2677
 2678func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2679	var err error
 2680	args := map[string]interface{}{}
 2681	var arg0 models.SetTitleInput
 2682	if tmp, ok := rawArgs["input"]; ok {
 2683		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2684		if err != nil {
 2685			return nil, err
 2686		}
 2687	}
 2688	args["input"] = arg0
 2689	return args, nil
 2690}
 2691
 2692func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2693	var err error
 2694	args := map[string]interface{}{}
 2695	var arg0 string
 2696	if tmp, ok := rawArgs["name"]; ok {
 2697		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2698		if err != nil {
 2699			return nil, err
 2700		}
 2701	}
 2702	args["name"] = arg0
 2703	return args, nil
 2704}
 2705
 2706func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2707	var err error
 2708	args := map[string]interface{}{}
 2709	var arg0 *string
 2710	if tmp, ok := rawArgs["ref"]; ok {
 2711		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2712		if err != nil {
 2713			return nil, err
 2714		}
 2715	}
 2716	args["ref"] = arg0
 2717	return args, nil
 2718}
 2719
 2720func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2721	var err error
 2722	args := map[string]interface{}{}
 2723	var arg0 *string
 2724	if tmp, ok := rawArgs["after"]; ok {
 2725		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2726		if err != nil {
 2727			return nil, err
 2728		}
 2729	}
 2730	args["after"] = arg0
 2731	var arg1 *string
 2732	if tmp, ok := rawArgs["before"]; ok {
 2733		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2734		if err != nil {
 2735			return nil, err
 2736		}
 2737	}
 2738	args["before"] = arg1
 2739	var arg2 *int
 2740	if tmp, ok := rawArgs["first"]; ok {
 2741		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2742		if err != nil {
 2743			return nil, err
 2744		}
 2745	}
 2746	args["first"] = arg2
 2747	var arg3 *int
 2748	if tmp, ok := rawArgs["last"]; ok {
 2749		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2750		if err != nil {
 2751			return nil, err
 2752		}
 2753	}
 2754	args["last"] = arg3
 2755	var arg4 *string
 2756	if tmp, ok := rawArgs["query"]; ok {
 2757		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2758		if err != nil {
 2759			return nil, err
 2760		}
 2761	}
 2762	args["query"] = arg4
 2763	return args, nil
 2764}
 2765
 2766func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2767	var err error
 2768	args := map[string]interface{}{}
 2769	var arg0 *string
 2770	if tmp, ok := rawArgs["after"]; ok {
 2771		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2772		if err != nil {
 2773			return nil, err
 2774		}
 2775	}
 2776	args["after"] = arg0
 2777	var arg1 *string
 2778	if tmp, ok := rawArgs["before"]; ok {
 2779		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2780		if err != nil {
 2781			return nil, err
 2782		}
 2783	}
 2784	args["before"] = arg1
 2785	var arg2 *int
 2786	if tmp, ok := rawArgs["first"]; ok {
 2787		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2788		if err != nil {
 2789			return nil, err
 2790		}
 2791	}
 2792	args["first"] = arg2
 2793	var arg3 *int
 2794	if tmp, ok := rawArgs["last"]; ok {
 2795		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2796		if err != nil {
 2797			return nil, err
 2798		}
 2799	}
 2800	args["last"] = arg3
 2801	return args, nil
 2802}
 2803
 2804func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2805	var err error
 2806	args := map[string]interface{}{}
 2807	var arg0 string
 2808	if tmp, ok := rawArgs["prefix"]; ok {
 2809		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2810		if err != nil {
 2811			return nil, err
 2812		}
 2813	}
 2814	args["prefix"] = arg0
 2815	return args, nil
 2816}
 2817
 2818func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2819	var err error
 2820	args := map[string]interface{}{}
 2821	var arg0 string
 2822	if tmp, ok := rawArgs["prefix"]; ok {
 2823		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2824		if err != nil {
 2825			return nil, err
 2826		}
 2827	}
 2828	args["prefix"] = arg0
 2829	return args, nil
 2830}
 2831
 2832func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2833	var err error
 2834	args := map[string]interface{}{}
 2835	var arg0 *string
 2836	if tmp, ok := rawArgs["after"]; ok {
 2837		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2838		if err != nil {
 2839			return nil, err
 2840		}
 2841	}
 2842	args["after"] = arg0
 2843	var arg1 *string
 2844	if tmp, ok := rawArgs["before"]; ok {
 2845		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2846		if err != nil {
 2847			return nil, err
 2848		}
 2849	}
 2850	args["before"] = arg1
 2851	var arg2 *int
 2852	if tmp, ok := rawArgs["first"]; ok {
 2853		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2854		if err != nil {
 2855			return nil, err
 2856		}
 2857	}
 2858	args["first"] = arg2
 2859	var arg3 *int
 2860	if tmp, ok := rawArgs["last"]; ok {
 2861		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2862		if err != nil {
 2863			return nil, err
 2864		}
 2865	}
 2866	args["last"] = arg3
 2867	return args, nil
 2868}
 2869
 2870func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2871	var err error
 2872	args := map[string]interface{}{}
 2873	var arg0 bool
 2874	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2875		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2876		if err != nil {
 2877			return nil, err
 2878		}
 2879	}
 2880	args["includeDeprecated"] = arg0
 2881	return args, nil
 2882}
 2883
 2884func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2885	var err error
 2886	args := map[string]interface{}{}
 2887	var arg0 bool
 2888	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2889		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2890		if err != nil {
 2891			return nil, err
 2892		}
 2893	}
 2894	args["includeDeprecated"] = arg0
 2895	return args, nil
 2896}
 2897
 2898// endregion ***************************** args.gotpl *****************************
 2899
 2900// region    ************************** directives.gotpl **************************
 2901
 2902// endregion ************************** directives.gotpl **************************
 2903
 2904// region    **************************** field.gotpl *****************************
 2905
 2906func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2907	defer func() {
 2908		if r := recover(); r != nil {
 2909			ec.Error(ctx, ec.Recover(ctx, r))
 2910			ret = graphql.Null
 2911		}
 2912	}()
 2913	fc := &graphql.FieldContext{
 2914		Object:   "AddCommentOperation",
 2915		Field:    field,
 2916		Args:     nil,
 2917		IsMethod: true,
 2918	}
 2919
 2920	ctx = graphql.WithFieldContext(ctx, fc)
 2921	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2922		ctx = rctx // use context from middleware stack in children
 2923		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 2924	})
 2925	if err != nil {
 2926		ec.Error(ctx, err)
 2927		return graphql.Null
 2928	}
 2929	if resTmp == nil {
 2930		if !graphql.HasFieldError(ctx, fc) {
 2931			ec.Errorf(ctx, "must not be null")
 2932		}
 2933		return graphql.Null
 2934	}
 2935	res := resTmp.(string)
 2936	fc.Result = res
 2937	return ec.marshalNString2string(ctx, field.Selections, res)
 2938}
 2939
 2940func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2941	defer func() {
 2942		if r := recover(); r != nil {
 2943			ec.Error(ctx, ec.Recover(ctx, r))
 2944			ret = graphql.Null
 2945		}
 2946	}()
 2947	fc := &graphql.FieldContext{
 2948		Object:   "AddCommentOperation",
 2949		Field:    field,
 2950		Args:     nil,
 2951		IsMethod: true,
 2952	}
 2953
 2954	ctx = graphql.WithFieldContext(ctx, fc)
 2955	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2956		ctx = rctx // use context from middleware stack in children
 2957		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
 2958	})
 2959	if err != nil {
 2960		ec.Error(ctx, err)
 2961		return graphql.Null
 2962	}
 2963	if resTmp == nil {
 2964		if !graphql.HasFieldError(ctx, fc) {
 2965			ec.Errorf(ctx, "must not be null")
 2966		}
 2967		return graphql.Null
 2968	}
 2969	res := resTmp.(models.IdentityWrapper)
 2970	fc.Result = res
 2971	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 2972}
 2973
 2974func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2975	defer func() {
 2976		if r := recover(); r != nil {
 2977			ec.Error(ctx, ec.Recover(ctx, r))
 2978			ret = graphql.Null
 2979		}
 2980	}()
 2981	fc := &graphql.FieldContext{
 2982		Object:   "AddCommentOperation",
 2983		Field:    field,
 2984		Args:     nil,
 2985		IsMethod: true,
 2986	}
 2987
 2988	ctx = graphql.WithFieldContext(ctx, fc)
 2989	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2990		ctx = rctx // use context from middleware stack in children
 2991		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 2992	})
 2993	if err != nil {
 2994		ec.Error(ctx, err)
 2995		return graphql.Null
 2996	}
 2997	if resTmp == nil {
 2998		if !graphql.HasFieldError(ctx, fc) {
 2999			ec.Errorf(ctx, "must not be null")
 3000		}
 3001		return graphql.Null
 3002	}
 3003	res := resTmp.(*time.Time)
 3004	fc.Result = res
 3005	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3006}
 3007
 3008func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3009	defer func() {
 3010		if r := recover(); r != nil {
 3011			ec.Error(ctx, ec.Recover(ctx, r))
 3012			ret = graphql.Null
 3013		}
 3014	}()
 3015	fc := &graphql.FieldContext{
 3016		Object:   "AddCommentOperation",
 3017		Field:    field,
 3018		Args:     nil,
 3019		IsMethod: false,
 3020	}
 3021
 3022	ctx = graphql.WithFieldContext(ctx, fc)
 3023	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3024		ctx = rctx // use context from middleware stack in children
 3025		return obj.Message, nil
 3026	})
 3027	if err != nil {
 3028		ec.Error(ctx, err)
 3029		return graphql.Null
 3030	}
 3031	if resTmp == nil {
 3032		if !graphql.HasFieldError(ctx, fc) {
 3033			ec.Errorf(ctx, "must not be null")
 3034		}
 3035		return graphql.Null
 3036	}
 3037	res := resTmp.(string)
 3038	fc.Result = res
 3039	return ec.marshalNString2string(ctx, field.Selections, res)
 3040}
 3041
 3042func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3043	defer func() {
 3044		if r := recover(); r != nil {
 3045			ec.Error(ctx, ec.Recover(ctx, r))
 3046			ret = graphql.Null
 3047		}
 3048	}()
 3049	fc := &graphql.FieldContext{
 3050		Object:   "AddCommentOperation",
 3051		Field:    field,
 3052		Args:     nil,
 3053		IsMethod: false,
 3054	}
 3055
 3056	ctx = graphql.WithFieldContext(ctx, fc)
 3057	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3058		ctx = rctx // use context from middleware stack in children
 3059		return obj.Files, nil
 3060	})
 3061	if err != nil {
 3062		ec.Error(ctx, err)
 3063		return graphql.Null
 3064	}
 3065	if resTmp == nil {
 3066		if !graphql.HasFieldError(ctx, fc) {
 3067			ec.Errorf(ctx, "must not be null")
 3068		}
 3069		return graphql.Null
 3070	}
 3071	res := resTmp.([]git.Hash)
 3072	fc.Result = res
 3073	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3074}
 3075
 3076func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3077	defer func() {
 3078		if r := recover(); r != nil {
 3079			ec.Error(ctx, ec.Recover(ctx, r))
 3080			ret = graphql.Null
 3081		}
 3082	}()
 3083	fc := &graphql.FieldContext{
 3084		Object:   "AddCommentPayload",
 3085		Field:    field,
 3086		Args:     nil,
 3087		IsMethod: false,
 3088	}
 3089
 3090	ctx = graphql.WithFieldContext(ctx, fc)
 3091	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3092		ctx = rctx // use context from middleware stack in children
 3093		return obj.ClientMutationID, nil
 3094	})
 3095	if err != nil {
 3096		ec.Error(ctx, err)
 3097		return graphql.Null
 3098	}
 3099	if resTmp == nil {
 3100		return graphql.Null
 3101	}
 3102	res := resTmp.(*string)
 3103	fc.Result = res
 3104	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3105}
 3106
 3107func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3108	defer func() {
 3109		if r := recover(); r != nil {
 3110			ec.Error(ctx, ec.Recover(ctx, r))
 3111			ret = graphql.Null
 3112		}
 3113	}()
 3114	fc := &graphql.FieldContext{
 3115		Object:   "AddCommentPayload",
 3116		Field:    field,
 3117		Args:     nil,
 3118		IsMethod: false,
 3119	}
 3120
 3121	ctx = graphql.WithFieldContext(ctx, fc)
 3122	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3123		ctx = rctx // use context from middleware stack in children
 3124		return obj.Bug, nil
 3125	})
 3126	if err != nil {
 3127		ec.Error(ctx, err)
 3128		return graphql.Null
 3129	}
 3130	if resTmp == nil {
 3131		if !graphql.HasFieldError(ctx, fc) {
 3132			ec.Errorf(ctx, "must not be null")
 3133		}
 3134		return graphql.Null
 3135	}
 3136	res := resTmp.(models.BugWrapper)
 3137	fc.Result = res
 3138	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 3139}
 3140
 3141func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3142	defer func() {
 3143		if r := recover(); r != nil {
 3144			ec.Error(ctx, ec.Recover(ctx, r))
 3145			ret = graphql.Null
 3146		}
 3147	}()
 3148	fc := &graphql.FieldContext{
 3149		Object:   "AddCommentPayload",
 3150		Field:    field,
 3151		Args:     nil,
 3152		IsMethod: false,
 3153	}
 3154
 3155	ctx = graphql.WithFieldContext(ctx, fc)
 3156	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3157		ctx = rctx // use context from middleware stack in children
 3158		return obj.Operation, nil
 3159	})
 3160	if err != nil {
 3161		ec.Error(ctx, err)
 3162		return graphql.Null
 3163	}
 3164	if resTmp == nil {
 3165		if !graphql.HasFieldError(ctx, fc) {
 3166			ec.Errorf(ctx, "must not be null")
 3167		}
 3168		return graphql.Null
 3169	}
 3170	res := resTmp.(*bug.AddCommentOperation)
 3171	fc.Result = res
 3172	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3173}
 3174
 3175func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3176	defer func() {
 3177		if r := recover(); r != nil {
 3178			ec.Error(ctx, ec.Recover(ctx, r))
 3179			ret = graphql.Null
 3180		}
 3181	}()
 3182	fc := &graphql.FieldContext{
 3183		Object:   "AddCommentTimelineItem",
 3184		Field:    field,
 3185		Args:     nil,
 3186		IsMethod: true,
 3187	}
 3188
 3189	ctx = graphql.WithFieldContext(ctx, fc)
 3190	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3191		ctx = rctx // use context from middleware stack in children
 3192		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3193	})
 3194	if err != nil {
 3195		ec.Error(ctx, err)
 3196		return graphql.Null
 3197	}
 3198	if resTmp == nil {
 3199		if !graphql.HasFieldError(ctx, fc) {
 3200			ec.Errorf(ctx, "must not be null")
 3201		}
 3202		return graphql.Null
 3203	}
 3204	res := resTmp.(string)
 3205	fc.Result = res
 3206	return ec.marshalNString2string(ctx, field.Selections, res)
 3207}
 3208
 3209func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3210	defer func() {
 3211		if r := recover(); r != nil {
 3212			ec.Error(ctx, ec.Recover(ctx, r))
 3213			ret = graphql.Null
 3214		}
 3215	}()
 3216	fc := &graphql.FieldContext{
 3217		Object:   "AddCommentTimelineItem",
 3218		Field:    field,
 3219		Args:     nil,
 3220		IsMethod: true,
 3221	}
 3222
 3223	ctx = graphql.WithFieldContext(ctx, fc)
 3224	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3225		ctx = rctx // use context from middleware stack in children
 3226		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
 3227	})
 3228	if err != nil {
 3229		ec.Error(ctx, err)
 3230		return graphql.Null
 3231	}
 3232	if resTmp == nil {
 3233		if !graphql.HasFieldError(ctx, fc) {
 3234			ec.Errorf(ctx, "must not be null")
 3235		}
 3236		return graphql.Null
 3237	}
 3238	res := resTmp.(models.IdentityWrapper)
 3239	fc.Result = res
 3240	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3241}
 3242
 3243func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3244	defer func() {
 3245		if r := recover(); r != nil {
 3246			ec.Error(ctx, ec.Recover(ctx, r))
 3247			ret = graphql.Null
 3248		}
 3249	}()
 3250	fc := &graphql.FieldContext{
 3251		Object:   "AddCommentTimelineItem",
 3252		Field:    field,
 3253		Args:     nil,
 3254		IsMethod: false,
 3255	}
 3256
 3257	ctx = graphql.WithFieldContext(ctx, fc)
 3258	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3259		ctx = rctx // use context from middleware stack in children
 3260		return obj.Message, nil
 3261	})
 3262	if err != nil {
 3263		ec.Error(ctx, err)
 3264		return graphql.Null
 3265	}
 3266	if resTmp == nil {
 3267		if !graphql.HasFieldError(ctx, fc) {
 3268			ec.Errorf(ctx, "must not be null")
 3269		}
 3270		return graphql.Null
 3271	}
 3272	res := resTmp.(string)
 3273	fc.Result = res
 3274	return ec.marshalNString2string(ctx, field.Selections, res)
 3275}
 3276
 3277func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3278	defer func() {
 3279		if r := recover(); r != nil {
 3280			ec.Error(ctx, ec.Recover(ctx, r))
 3281			ret = graphql.Null
 3282		}
 3283	}()
 3284	fc := &graphql.FieldContext{
 3285		Object:   "AddCommentTimelineItem",
 3286		Field:    field,
 3287		Args:     nil,
 3288		IsMethod: true,
 3289	}
 3290
 3291	ctx = graphql.WithFieldContext(ctx, fc)
 3292	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3293		ctx = rctx // use context from middleware stack in children
 3294		return obj.MessageIsEmpty(), nil
 3295	})
 3296	if err != nil {
 3297		ec.Error(ctx, err)
 3298		return graphql.Null
 3299	}
 3300	if resTmp == nil {
 3301		if !graphql.HasFieldError(ctx, fc) {
 3302			ec.Errorf(ctx, "must not be null")
 3303		}
 3304		return graphql.Null
 3305	}
 3306	res := resTmp.(bool)
 3307	fc.Result = res
 3308	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3309}
 3310
 3311func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3312	defer func() {
 3313		if r := recover(); r != nil {
 3314			ec.Error(ctx, ec.Recover(ctx, r))
 3315			ret = graphql.Null
 3316		}
 3317	}()
 3318	fc := &graphql.FieldContext{
 3319		Object:   "AddCommentTimelineItem",
 3320		Field:    field,
 3321		Args:     nil,
 3322		IsMethod: false,
 3323	}
 3324
 3325	ctx = graphql.WithFieldContext(ctx, fc)
 3326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3327		ctx = rctx // use context from middleware stack in children
 3328		return obj.Files, nil
 3329	})
 3330	if err != nil {
 3331		ec.Error(ctx, err)
 3332		return graphql.Null
 3333	}
 3334	if resTmp == nil {
 3335		if !graphql.HasFieldError(ctx, fc) {
 3336			ec.Errorf(ctx, "must not be null")
 3337		}
 3338		return graphql.Null
 3339	}
 3340	res := resTmp.([]git.Hash)
 3341	fc.Result = res
 3342	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3343}
 3344
 3345func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3346	defer func() {
 3347		if r := recover(); r != nil {
 3348			ec.Error(ctx, ec.Recover(ctx, r))
 3349			ret = graphql.Null
 3350		}
 3351	}()
 3352	fc := &graphql.FieldContext{
 3353		Object:   "AddCommentTimelineItem",
 3354		Field:    field,
 3355		Args:     nil,
 3356		IsMethod: true,
 3357	}
 3358
 3359	ctx = graphql.WithFieldContext(ctx, fc)
 3360	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3361		ctx = rctx // use context from middleware stack in children
 3362		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3363	})
 3364	if err != nil {
 3365		ec.Error(ctx, err)
 3366		return graphql.Null
 3367	}
 3368	if resTmp == nil {
 3369		if !graphql.HasFieldError(ctx, fc) {
 3370			ec.Errorf(ctx, "must not be null")
 3371		}
 3372		return graphql.Null
 3373	}
 3374	res := resTmp.(*time.Time)
 3375	fc.Result = res
 3376	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3377}
 3378
 3379func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3380	defer func() {
 3381		if r := recover(); r != nil {
 3382			ec.Error(ctx, ec.Recover(ctx, r))
 3383			ret = graphql.Null
 3384		}
 3385	}()
 3386	fc := &graphql.FieldContext{
 3387		Object:   "AddCommentTimelineItem",
 3388		Field:    field,
 3389		Args:     nil,
 3390		IsMethod: true,
 3391	}
 3392
 3393	ctx = graphql.WithFieldContext(ctx, fc)
 3394	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3395		ctx = rctx // use context from middleware stack in children
 3396		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3397	})
 3398	if err != nil {
 3399		ec.Error(ctx, err)
 3400		return graphql.Null
 3401	}
 3402	if resTmp == nil {
 3403		if !graphql.HasFieldError(ctx, fc) {
 3404			ec.Errorf(ctx, "must not be null")
 3405		}
 3406		return graphql.Null
 3407	}
 3408	res := resTmp.(*time.Time)
 3409	fc.Result = res
 3410	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3411}
 3412
 3413func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3414	defer func() {
 3415		if r := recover(); r != nil {
 3416			ec.Error(ctx, ec.Recover(ctx, r))
 3417			ret = graphql.Null
 3418		}
 3419	}()
 3420	fc := &graphql.FieldContext{
 3421		Object:   "AddCommentTimelineItem",
 3422		Field:    field,
 3423		Args:     nil,
 3424		IsMethod: true,
 3425	}
 3426
 3427	ctx = graphql.WithFieldContext(ctx, fc)
 3428	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3429		ctx = rctx // use context from middleware stack in children
 3430		return obj.Edited(), nil
 3431	})
 3432	if err != nil {
 3433		ec.Error(ctx, err)
 3434		return graphql.Null
 3435	}
 3436	if resTmp == nil {
 3437		if !graphql.HasFieldError(ctx, fc) {
 3438			ec.Errorf(ctx, "must not be null")
 3439		}
 3440		return graphql.Null
 3441	}
 3442	res := resTmp.(bool)
 3443	fc.Result = res
 3444	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3445}
 3446
 3447func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3448	defer func() {
 3449		if r := recover(); r != nil {
 3450			ec.Error(ctx, ec.Recover(ctx, r))
 3451			ret = graphql.Null
 3452		}
 3453	}()
 3454	fc := &graphql.FieldContext{
 3455		Object:   "AddCommentTimelineItem",
 3456		Field:    field,
 3457		Args:     nil,
 3458		IsMethod: false,
 3459	}
 3460
 3461	ctx = graphql.WithFieldContext(ctx, fc)
 3462	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3463		ctx = rctx // use context from middleware stack in children
 3464		return obj.History, nil
 3465	})
 3466	if err != nil {
 3467		ec.Error(ctx, err)
 3468		return graphql.Null
 3469	}
 3470	if resTmp == nil {
 3471		if !graphql.HasFieldError(ctx, fc) {
 3472			ec.Errorf(ctx, "must not be null")
 3473		}
 3474		return graphql.Null
 3475	}
 3476	res := resTmp.([]bug.CommentHistoryStep)
 3477	fc.Result = res
 3478	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3479}
 3480
 3481func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3482	defer func() {
 3483		if r := recover(); r != nil {
 3484			ec.Error(ctx, ec.Recover(ctx, r))
 3485			ret = graphql.Null
 3486		}
 3487	}()
 3488	fc := &graphql.FieldContext{
 3489		Object:   "Bug",
 3490		Field:    field,
 3491		Args:     nil,
 3492		IsMethod: true,
 3493	}
 3494
 3495	ctx = graphql.WithFieldContext(ctx, fc)
 3496	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3497		ctx = rctx // use context from middleware stack in children
 3498		return ec.resolvers.Bug().ID(rctx, obj)
 3499	})
 3500	if err != nil {
 3501		ec.Error(ctx, err)
 3502		return graphql.Null
 3503	}
 3504	if resTmp == nil {
 3505		if !graphql.HasFieldError(ctx, fc) {
 3506			ec.Errorf(ctx, "must not be null")
 3507		}
 3508		return graphql.Null
 3509	}
 3510	res := resTmp.(string)
 3511	fc.Result = res
 3512	return ec.marshalNString2string(ctx, field.Selections, res)
 3513}
 3514
 3515func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3516	defer func() {
 3517		if r := recover(); r != nil {
 3518			ec.Error(ctx, ec.Recover(ctx, r))
 3519			ret = graphql.Null
 3520		}
 3521	}()
 3522	fc := &graphql.FieldContext{
 3523		Object:   "Bug",
 3524		Field:    field,
 3525		Args:     nil,
 3526		IsMethod: true,
 3527	}
 3528
 3529	ctx = graphql.WithFieldContext(ctx, fc)
 3530	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3531		ctx = rctx // use context from middleware stack in children
 3532		return ec.resolvers.Bug().HumanID(rctx, obj)
 3533	})
 3534	if err != nil {
 3535		ec.Error(ctx, err)
 3536		return graphql.Null
 3537	}
 3538	if resTmp == nil {
 3539		if !graphql.HasFieldError(ctx, fc) {
 3540			ec.Errorf(ctx, "must not be null")
 3541		}
 3542		return graphql.Null
 3543	}
 3544	res := resTmp.(string)
 3545	fc.Result = res
 3546	return ec.marshalNString2string(ctx, field.Selections, res)
 3547}
 3548
 3549func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3550	defer func() {
 3551		if r := recover(); r != nil {
 3552			ec.Error(ctx, ec.Recover(ctx, r))
 3553			ret = graphql.Null
 3554		}
 3555	}()
 3556	fc := &graphql.FieldContext{
 3557		Object:   "Bug",
 3558		Field:    field,
 3559		Args:     nil,
 3560		IsMethod: true,
 3561	}
 3562
 3563	ctx = graphql.WithFieldContext(ctx, fc)
 3564	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3565		ctx = rctx // use context from middleware stack in children
 3566		return ec.resolvers.Bug().Status(rctx, obj)
 3567	})
 3568	if err != nil {
 3569		ec.Error(ctx, err)
 3570		return graphql.Null
 3571	}
 3572	if resTmp == nil {
 3573		if !graphql.HasFieldError(ctx, fc) {
 3574			ec.Errorf(ctx, "must not be null")
 3575		}
 3576		return graphql.Null
 3577	}
 3578	res := resTmp.(models.Status)
 3579	fc.Result = res
 3580	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3581}
 3582
 3583func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3584	defer func() {
 3585		if r := recover(); r != nil {
 3586			ec.Error(ctx, ec.Recover(ctx, r))
 3587			ret = graphql.Null
 3588		}
 3589	}()
 3590	fc := &graphql.FieldContext{
 3591		Object:   "Bug",
 3592		Field:    field,
 3593		Args:     nil,
 3594		IsMethod: true,
 3595	}
 3596
 3597	ctx = graphql.WithFieldContext(ctx, fc)
 3598	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3599		ctx = rctx // use context from middleware stack in children
 3600		return obj.Title(), nil
 3601	})
 3602	if err != nil {
 3603		ec.Error(ctx, err)
 3604		return graphql.Null
 3605	}
 3606	if resTmp == nil {
 3607		if !graphql.HasFieldError(ctx, fc) {
 3608			ec.Errorf(ctx, "must not be null")
 3609		}
 3610		return graphql.Null
 3611	}
 3612	res := resTmp.(string)
 3613	fc.Result = res
 3614	return ec.marshalNString2string(ctx, field.Selections, res)
 3615}
 3616
 3617func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3618	defer func() {
 3619		if r := recover(); r != nil {
 3620			ec.Error(ctx, ec.Recover(ctx, r))
 3621			ret = graphql.Null
 3622		}
 3623	}()
 3624	fc := &graphql.FieldContext{
 3625		Object:   "Bug",
 3626		Field:    field,
 3627		Args:     nil,
 3628		IsMethod: true,
 3629	}
 3630
 3631	ctx = graphql.WithFieldContext(ctx, fc)
 3632	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3633		ctx = rctx // use context from middleware stack in children
 3634		return obj.Labels(), nil
 3635	})
 3636	if err != nil {
 3637		ec.Error(ctx, err)
 3638		return graphql.Null
 3639	}
 3640	if resTmp == nil {
 3641		if !graphql.HasFieldError(ctx, fc) {
 3642			ec.Errorf(ctx, "must not be null")
 3643		}
 3644		return graphql.Null
 3645	}
 3646	res := resTmp.([]bug.Label)
 3647	fc.Result = res
 3648	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 3649}
 3650
 3651func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3652	defer func() {
 3653		if r := recover(); r != nil {
 3654			ec.Error(ctx, ec.Recover(ctx, r))
 3655			ret = graphql.Null
 3656		}
 3657	}()
 3658	fc := &graphql.FieldContext{
 3659		Object:   "Bug",
 3660		Field:    field,
 3661		Args:     nil,
 3662		IsMethod: true,
 3663	}
 3664
 3665	ctx = graphql.WithFieldContext(ctx, fc)
 3666	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3667		ctx = rctx // use context from middleware stack in children
 3668		return obj.Author()
 3669	})
 3670	if err != nil {
 3671		ec.Error(ctx, err)
 3672		return graphql.Null
 3673	}
 3674	if resTmp == nil {
 3675		if !graphql.HasFieldError(ctx, fc) {
 3676			ec.Errorf(ctx, "must not be null")
 3677		}
 3678		return graphql.Null
 3679	}
 3680	res := resTmp.(models.IdentityWrapper)
 3681	fc.Result = res
 3682	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3683}
 3684
 3685func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3686	defer func() {
 3687		if r := recover(); r != nil {
 3688			ec.Error(ctx, ec.Recover(ctx, r))
 3689			ret = graphql.Null
 3690		}
 3691	}()
 3692	fc := &graphql.FieldContext{
 3693		Object:   "Bug",
 3694		Field:    field,
 3695		Args:     nil,
 3696		IsMethod: true,
 3697	}
 3698
 3699	ctx = graphql.WithFieldContext(ctx, fc)
 3700	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3701		ctx = rctx // use context from middleware stack in children
 3702		return obj.CreatedAt(), nil
 3703	})
 3704	if err != nil {
 3705		ec.Error(ctx, err)
 3706		return graphql.Null
 3707	}
 3708	if resTmp == nil {
 3709		if !graphql.HasFieldError(ctx, fc) {
 3710			ec.Errorf(ctx, "must not be null")
 3711		}
 3712		return graphql.Null
 3713	}
 3714	res := resTmp.(time.Time)
 3715	fc.Result = res
 3716	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3717}
 3718
 3719func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3720	defer func() {
 3721		if r := recover(); r != nil {
 3722			ec.Error(ctx, ec.Recover(ctx, r))
 3723			ret = graphql.Null
 3724		}
 3725	}()
 3726	fc := &graphql.FieldContext{
 3727		Object:   "Bug",
 3728		Field:    field,
 3729		Args:     nil,
 3730		IsMethod: true,
 3731	}
 3732
 3733	ctx = graphql.WithFieldContext(ctx, fc)
 3734	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3735		ctx = rctx // use context from middleware stack in children
 3736		return obj.LastEdit(), nil
 3737	})
 3738	if err != nil {
 3739		ec.Error(ctx, err)
 3740		return graphql.Null
 3741	}
 3742	if resTmp == nil {
 3743		if !graphql.HasFieldError(ctx, fc) {
 3744			ec.Errorf(ctx, "must not be null")
 3745		}
 3746		return graphql.Null
 3747	}
 3748	res := resTmp.(time.Time)
 3749	fc.Result = res
 3750	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3751}
 3752
 3753func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3754	defer func() {
 3755		if r := recover(); r != nil {
 3756			ec.Error(ctx, ec.Recover(ctx, r))
 3757			ret = graphql.Null
 3758		}
 3759	}()
 3760	fc := &graphql.FieldContext{
 3761		Object:   "Bug",
 3762		Field:    field,
 3763		Args:     nil,
 3764		IsMethod: true,
 3765	}
 3766
 3767	ctx = graphql.WithFieldContext(ctx, fc)
 3768	rawArgs := field.ArgumentMap(ec.Variables)
 3769	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3770	if err != nil {
 3771		ec.Error(ctx, err)
 3772		return graphql.Null
 3773	}
 3774	fc.Args = args
 3775	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3776		ctx = rctx // use context from middleware stack in children
 3777		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3778	})
 3779	if err != nil {
 3780		ec.Error(ctx, err)
 3781		return graphql.Null
 3782	}
 3783	if resTmp == nil {
 3784		if !graphql.HasFieldError(ctx, fc) {
 3785			ec.Errorf(ctx, "must not be null")
 3786		}
 3787		return graphql.Null
 3788	}
 3789	res := resTmp.(*models.IdentityConnection)
 3790	fc.Result = res
 3791	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3792}
 3793
 3794func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3795	defer func() {
 3796		if r := recover(); r != nil {
 3797			ec.Error(ctx, ec.Recover(ctx, r))
 3798			ret = graphql.Null
 3799		}
 3800	}()
 3801	fc := &graphql.FieldContext{
 3802		Object:   "Bug",
 3803		Field:    field,
 3804		Args:     nil,
 3805		IsMethod: true,
 3806	}
 3807
 3808	ctx = graphql.WithFieldContext(ctx, fc)
 3809	rawArgs := field.ArgumentMap(ec.Variables)
 3810	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3811	if err != nil {
 3812		ec.Error(ctx, err)
 3813		return graphql.Null
 3814	}
 3815	fc.Args = args
 3816	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3817		ctx = rctx // use context from middleware stack in children
 3818		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3819	})
 3820	if err != nil {
 3821		ec.Error(ctx, err)
 3822		return graphql.Null
 3823	}
 3824	if resTmp == nil {
 3825		if !graphql.HasFieldError(ctx, fc) {
 3826			ec.Errorf(ctx, "must not be null")
 3827		}
 3828		return graphql.Null
 3829	}
 3830	res := resTmp.(*models.IdentityConnection)
 3831	fc.Result = res
 3832	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3833}
 3834
 3835func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3836	defer func() {
 3837		if r := recover(); r != nil {
 3838			ec.Error(ctx, ec.Recover(ctx, r))
 3839			ret = graphql.Null
 3840		}
 3841	}()
 3842	fc := &graphql.FieldContext{
 3843		Object:   "Bug",
 3844		Field:    field,
 3845		Args:     nil,
 3846		IsMethod: true,
 3847	}
 3848
 3849	ctx = graphql.WithFieldContext(ctx, fc)
 3850	rawArgs := field.ArgumentMap(ec.Variables)
 3851	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3852	if err != nil {
 3853		ec.Error(ctx, err)
 3854		return graphql.Null
 3855	}
 3856	fc.Args = args
 3857	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3858		ctx = rctx // use context from middleware stack in children
 3859		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3860	})
 3861	if err != nil {
 3862		ec.Error(ctx, err)
 3863		return graphql.Null
 3864	}
 3865	if resTmp == nil {
 3866		if !graphql.HasFieldError(ctx, fc) {
 3867			ec.Errorf(ctx, "must not be null")
 3868		}
 3869		return graphql.Null
 3870	}
 3871	res := resTmp.(*models.CommentConnection)
 3872	fc.Result = res
 3873	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3874}
 3875
 3876func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3877	defer func() {
 3878		if r := recover(); r != nil {
 3879			ec.Error(ctx, ec.Recover(ctx, r))
 3880			ret = graphql.Null
 3881		}
 3882	}()
 3883	fc := &graphql.FieldContext{
 3884		Object:   "Bug",
 3885		Field:    field,
 3886		Args:     nil,
 3887		IsMethod: true,
 3888	}
 3889
 3890	ctx = graphql.WithFieldContext(ctx, fc)
 3891	rawArgs := field.ArgumentMap(ec.Variables)
 3892	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3893	if err != nil {
 3894		ec.Error(ctx, err)
 3895		return graphql.Null
 3896	}
 3897	fc.Args = args
 3898	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3899		ctx = rctx // use context from middleware stack in children
 3900		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3901	})
 3902	if err != nil {
 3903		ec.Error(ctx, err)
 3904		return graphql.Null
 3905	}
 3906	if resTmp == nil {
 3907		if !graphql.HasFieldError(ctx, fc) {
 3908			ec.Errorf(ctx, "must not be null")
 3909		}
 3910		return graphql.Null
 3911	}
 3912	res := resTmp.(*models.TimelineItemConnection)
 3913	fc.Result = res
 3914	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 3915}
 3916
 3917func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3918	defer func() {
 3919		if r := recover(); r != nil {
 3920			ec.Error(ctx, ec.Recover(ctx, r))
 3921			ret = graphql.Null
 3922		}
 3923	}()
 3924	fc := &graphql.FieldContext{
 3925		Object:   "Bug",
 3926		Field:    field,
 3927		Args:     nil,
 3928		IsMethod: true,
 3929	}
 3930
 3931	ctx = graphql.WithFieldContext(ctx, fc)
 3932	rawArgs := field.ArgumentMap(ec.Variables)
 3933	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 3934	if err != nil {
 3935		ec.Error(ctx, err)
 3936		return graphql.Null
 3937	}
 3938	fc.Args = args
 3939	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3940		ctx = rctx // use context from middleware stack in children
 3941		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3942	})
 3943	if err != nil {
 3944		ec.Error(ctx, err)
 3945		return graphql.Null
 3946	}
 3947	if resTmp == nil {
 3948		if !graphql.HasFieldError(ctx, fc) {
 3949			ec.Errorf(ctx, "must not be null")
 3950		}
 3951		return graphql.Null
 3952	}
 3953	res := resTmp.(*models.OperationConnection)
 3954	fc.Result = res
 3955	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 3956}
 3957
 3958func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 3959	defer func() {
 3960		if r := recover(); r != nil {
 3961			ec.Error(ctx, ec.Recover(ctx, r))
 3962			ret = graphql.Null
 3963		}
 3964	}()
 3965	fc := &graphql.FieldContext{
 3966		Object:   "BugConnection",
 3967		Field:    field,
 3968		Args:     nil,
 3969		IsMethod: false,
 3970	}
 3971
 3972	ctx = graphql.WithFieldContext(ctx, fc)
 3973	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3974		ctx = rctx // use context from middleware stack in children
 3975		return obj.Edges, nil
 3976	})
 3977	if err != nil {
 3978		ec.Error(ctx, err)
 3979		return graphql.Null
 3980	}
 3981	if resTmp == nil {
 3982		if !graphql.HasFieldError(ctx, fc) {
 3983			ec.Errorf(ctx, "must not be null")
 3984		}
 3985		return graphql.Null
 3986	}
 3987	res := resTmp.([]*models.BugEdge)
 3988	fc.Result = res
 3989	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 3990}
 3991
 3992func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 3993	defer func() {
 3994		if r := recover(); r != nil {
 3995			ec.Error(ctx, ec.Recover(ctx, r))
 3996			ret = graphql.Null
 3997		}
 3998	}()
 3999	fc := &graphql.FieldContext{
 4000		Object:   "BugConnection",
 4001		Field:    field,
 4002		Args:     nil,
 4003		IsMethod: false,
 4004	}
 4005
 4006	ctx = graphql.WithFieldContext(ctx, fc)
 4007	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4008		ctx = rctx // use context from middleware stack in children
 4009		return obj.Nodes, nil
 4010	})
 4011	if err != nil {
 4012		ec.Error(ctx, err)
 4013		return graphql.Null
 4014	}
 4015	if resTmp == nil {
 4016		if !graphql.HasFieldError(ctx, fc) {
 4017			ec.Errorf(ctx, "must not be null")
 4018		}
 4019		return graphql.Null
 4020	}
 4021	res := resTmp.([]models.BugWrapper)
 4022	fc.Result = res
 4023	return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
 4024}
 4025
 4026func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4027	defer func() {
 4028		if r := recover(); r != nil {
 4029			ec.Error(ctx, ec.Recover(ctx, r))
 4030			ret = graphql.Null
 4031		}
 4032	}()
 4033	fc := &graphql.FieldContext{
 4034		Object:   "BugConnection",
 4035		Field:    field,
 4036		Args:     nil,
 4037		IsMethod: false,
 4038	}
 4039
 4040	ctx = graphql.WithFieldContext(ctx, fc)
 4041	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4042		ctx = rctx // use context from middleware stack in children
 4043		return obj.PageInfo, nil
 4044	})
 4045	if err != nil {
 4046		ec.Error(ctx, err)
 4047		return graphql.Null
 4048	}
 4049	if resTmp == nil {
 4050		if !graphql.HasFieldError(ctx, fc) {
 4051			ec.Errorf(ctx, "must not be null")
 4052		}
 4053		return graphql.Null
 4054	}
 4055	res := resTmp.(*models.PageInfo)
 4056	fc.Result = res
 4057	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4058}
 4059
 4060func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4061	defer func() {
 4062		if r := recover(); r != nil {
 4063			ec.Error(ctx, ec.Recover(ctx, r))
 4064			ret = graphql.Null
 4065		}
 4066	}()
 4067	fc := &graphql.FieldContext{
 4068		Object:   "BugConnection",
 4069		Field:    field,
 4070		Args:     nil,
 4071		IsMethod: false,
 4072	}
 4073
 4074	ctx = graphql.WithFieldContext(ctx, fc)
 4075	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4076		ctx = rctx // use context from middleware stack in children
 4077		return obj.TotalCount, nil
 4078	})
 4079	if err != nil {
 4080		ec.Error(ctx, err)
 4081		return graphql.Null
 4082	}
 4083	if resTmp == nil {
 4084		if !graphql.HasFieldError(ctx, fc) {
 4085			ec.Errorf(ctx, "must not be null")
 4086		}
 4087		return graphql.Null
 4088	}
 4089	res := resTmp.(int)
 4090	fc.Result = res
 4091	return ec.marshalNInt2int(ctx, field.Selections, res)
 4092}
 4093
 4094func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4095	defer func() {
 4096		if r := recover(); r != nil {
 4097			ec.Error(ctx, ec.Recover(ctx, r))
 4098			ret = graphql.Null
 4099		}
 4100	}()
 4101	fc := &graphql.FieldContext{
 4102		Object:   "BugEdge",
 4103		Field:    field,
 4104		Args:     nil,
 4105		IsMethod: false,
 4106	}
 4107
 4108	ctx = graphql.WithFieldContext(ctx, fc)
 4109	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4110		ctx = rctx // use context from middleware stack in children
 4111		return obj.Cursor, nil
 4112	})
 4113	if err != nil {
 4114		ec.Error(ctx, err)
 4115		return graphql.Null
 4116	}
 4117	if resTmp == nil {
 4118		if !graphql.HasFieldError(ctx, fc) {
 4119			ec.Errorf(ctx, "must not be null")
 4120		}
 4121		return graphql.Null
 4122	}
 4123	res := resTmp.(string)
 4124	fc.Result = res
 4125	return ec.marshalNString2string(ctx, field.Selections, res)
 4126}
 4127
 4128func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4129	defer func() {
 4130		if r := recover(); r != nil {
 4131			ec.Error(ctx, ec.Recover(ctx, r))
 4132			ret = graphql.Null
 4133		}
 4134	}()
 4135	fc := &graphql.FieldContext{
 4136		Object:   "BugEdge",
 4137		Field:    field,
 4138		Args:     nil,
 4139		IsMethod: false,
 4140	}
 4141
 4142	ctx = graphql.WithFieldContext(ctx, fc)
 4143	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4144		ctx = rctx // use context from middleware stack in children
 4145		return obj.Node, nil
 4146	})
 4147	if err != nil {
 4148		ec.Error(ctx, err)
 4149		return graphql.Null
 4150	}
 4151	if resTmp == nil {
 4152		if !graphql.HasFieldError(ctx, fc) {
 4153			ec.Errorf(ctx, "must not be null")
 4154		}
 4155		return graphql.Null
 4156	}
 4157	res := resTmp.(models.BugWrapper)
 4158	fc.Result = res
 4159	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4160}
 4161
 4162func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4163	defer func() {
 4164		if r := recover(); r != nil {
 4165			ec.Error(ctx, ec.Recover(ctx, r))
 4166			ret = graphql.Null
 4167		}
 4168	}()
 4169	fc := &graphql.FieldContext{
 4170		Object:   "ChangeLabelPayload",
 4171		Field:    field,
 4172		Args:     nil,
 4173		IsMethod: false,
 4174	}
 4175
 4176	ctx = graphql.WithFieldContext(ctx, fc)
 4177	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4178		ctx = rctx // use context from middleware stack in children
 4179		return obj.ClientMutationID, nil
 4180	})
 4181	if err != nil {
 4182		ec.Error(ctx, err)
 4183		return graphql.Null
 4184	}
 4185	if resTmp == nil {
 4186		return graphql.Null
 4187	}
 4188	res := resTmp.(*string)
 4189	fc.Result = res
 4190	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4191}
 4192
 4193func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4194	defer func() {
 4195		if r := recover(); r != nil {
 4196			ec.Error(ctx, ec.Recover(ctx, r))
 4197			ret = graphql.Null
 4198		}
 4199	}()
 4200	fc := &graphql.FieldContext{
 4201		Object:   "ChangeLabelPayload",
 4202		Field:    field,
 4203		Args:     nil,
 4204		IsMethod: false,
 4205	}
 4206
 4207	ctx = graphql.WithFieldContext(ctx, fc)
 4208	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4209		ctx = rctx // use context from middleware stack in children
 4210		return obj.Bug, nil
 4211	})
 4212	if err != nil {
 4213		ec.Error(ctx, err)
 4214		return graphql.Null
 4215	}
 4216	if resTmp == nil {
 4217		if !graphql.HasFieldError(ctx, fc) {
 4218			ec.Errorf(ctx, "must not be null")
 4219		}
 4220		return graphql.Null
 4221	}
 4222	res := resTmp.(models.BugWrapper)
 4223	fc.Result = res
 4224	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4225}
 4226
 4227func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4228	defer func() {
 4229		if r := recover(); r != nil {
 4230			ec.Error(ctx, ec.Recover(ctx, r))
 4231			ret = graphql.Null
 4232		}
 4233	}()
 4234	fc := &graphql.FieldContext{
 4235		Object:   "ChangeLabelPayload",
 4236		Field:    field,
 4237		Args:     nil,
 4238		IsMethod: false,
 4239	}
 4240
 4241	ctx = graphql.WithFieldContext(ctx, fc)
 4242	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4243		ctx = rctx // use context from middleware stack in children
 4244		return obj.Operation, nil
 4245	})
 4246	if err != nil {
 4247		ec.Error(ctx, err)
 4248		return graphql.Null
 4249	}
 4250	if resTmp == nil {
 4251		if !graphql.HasFieldError(ctx, fc) {
 4252			ec.Errorf(ctx, "must not be null")
 4253		}
 4254		return graphql.Null
 4255	}
 4256	res := resTmp.(*bug.LabelChangeOperation)
 4257	fc.Result = res
 4258	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4259}
 4260
 4261func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4262	defer func() {
 4263		if r := recover(); r != nil {
 4264			ec.Error(ctx, ec.Recover(ctx, r))
 4265			ret = graphql.Null
 4266		}
 4267	}()
 4268	fc := &graphql.FieldContext{
 4269		Object:   "ChangeLabelPayload",
 4270		Field:    field,
 4271		Args:     nil,
 4272		IsMethod: false,
 4273	}
 4274
 4275	ctx = graphql.WithFieldContext(ctx, fc)
 4276	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4277		ctx = rctx // use context from middleware stack in children
 4278		return obj.Results, nil
 4279	})
 4280	if err != nil {
 4281		ec.Error(ctx, err)
 4282		return graphql.Null
 4283	}
 4284	if resTmp == nil {
 4285		if !graphql.HasFieldError(ctx, fc) {
 4286			ec.Errorf(ctx, "must not be null")
 4287		}
 4288		return graphql.Null
 4289	}
 4290	res := resTmp.([]*bug.LabelChangeResult)
 4291	fc.Result = res
 4292	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4293}
 4294
 4295func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4296	defer func() {
 4297		if r := recover(); r != nil {
 4298			ec.Error(ctx, ec.Recover(ctx, r))
 4299			ret = graphql.Null
 4300		}
 4301	}()
 4302	fc := &graphql.FieldContext{
 4303		Object:   "CloseBugPayload",
 4304		Field:    field,
 4305		Args:     nil,
 4306		IsMethod: false,
 4307	}
 4308
 4309	ctx = graphql.WithFieldContext(ctx, fc)
 4310	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4311		ctx = rctx // use context from middleware stack in children
 4312		return obj.ClientMutationID, nil
 4313	})
 4314	if err != nil {
 4315		ec.Error(ctx, err)
 4316		return graphql.Null
 4317	}
 4318	if resTmp == nil {
 4319		return graphql.Null
 4320	}
 4321	res := resTmp.(*string)
 4322	fc.Result = res
 4323	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4324}
 4325
 4326func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4327	defer func() {
 4328		if r := recover(); r != nil {
 4329			ec.Error(ctx, ec.Recover(ctx, r))
 4330			ret = graphql.Null
 4331		}
 4332	}()
 4333	fc := &graphql.FieldContext{
 4334		Object:   "CloseBugPayload",
 4335		Field:    field,
 4336		Args:     nil,
 4337		IsMethod: false,
 4338	}
 4339
 4340	ctx = graphql.WithFieldContext(ctx, fc)
 4341	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4342		ctx = rctx // use context from middleware stack in children
 4343		return obj.Bug, nil
 4344	})
 4345	if err != nil {
 4346		ec.Error(ctx, err)
 4347		return graphql.Null
 4348	}
 4349	if resTmp == nil {
 4350		if !graphql.HasFieldError(ctx, fc) {
 4351			ec.Errorf(ctx, "must not be null")
 4352		}
 4353		return graphql.Null
 4354	}
 4355	res := resTmp.(models.BugWrapper)
 4356	fc.Result = res
 4357	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4358}
 4359
 4360func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4361	defer func() {
 4362		if r := recover(); r != nil {
 4363			ec.Error(ctx, ec.Recover(ctx, r))
 4364			ret = graphql.Null
 4365		}
 4366	}()
 4367	fc := &graphql.FieldContext{
 4368		Object:   "CloseBugPayload",
 4369		Field:    field,
 4370		Args:     nil,
 4371		IsMethod: false,
 4372	}
 4373
 4374	ctx = graphql.WithFieldContext(ctx, fc)
 4375	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4376		ctx = rctx // use context from middleware stack in children
 4377		return obj.Operation, nil
 4378	})
 4379	if err != nil {
 4380		ec.Error(ctx, err)
 4381		return graphql.Null
 4382	}
 4383	if resTmp == nil {
 4384		if !graphql.HasFieldError(ctx, fc) {
 4385			ec.Errorf(ctx, "must not be null")
 4386		}
 4387		return graphql.Null
 4388	}
 4389	res := resTmp.(*bug.SetStatusOperation)
 4390	fc.Result = res
 4391	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4392}
 4393
 4394func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4395	defer func() {
 4396		if r := recover(); r != nil {
 4397			ec.Error(ctx, ec.Recover(ctx, r))
 4398			ret = graphql.Null
 4399		}
 4400	}()
 4401	fc := &graphql.FieldContext{
 4402		Object:   "Color",
 4403		Field:    field,
 4404		Args:     nil,
 4405		IsMethod: true,
 4406	}
 4407
 4408	ctx = graphql.WithFieldContext(ctx, fc)
 4409	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4410		ctx = rctx // use context from middleware stack in children
 4411		return ec.resolvers.Color().R(rctx, obj)
 4412	})
 4413	if err != nil {
 4414		ec.Error(ctx, err)
 4415		return graphql.Null
 4416	}
 4417	if resTmp == nil {
 4418		if !graphql.HasFieldError(ctx, fc) {
 4419			ec.Errorf(ctx, "must not be null")
 4420		}
 4421		return graphql.Null
 4422	}
 4423	res := resTmp.(int)
 4424	fc.Result = res
 4425	return ec.marshalNInt2int(ctx, field.Selections, res)
 4426}
 4427
 4428func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4429	defer func() {
 4430		if r := recover(); r != nil {
 4431			ec.Error(ctx, ec.Recover(ctx, r))
 4432			ret = graphql.Null
 4433		}
 4434	}()
 4435	fc := &graphql.FieldContext{
 4436		Object:   "Color",
 4437		Field:    field,
 4438		Args:     nil,
 4439		IsMethod: true,
 4440	}
 4441
 4442	ctx = graphql.WithFieldContext(ctx, fc)
 4443	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4444		ctx = rctx // use context from middleware stack in children
 4445		return ec.resolvers.Color().G(rctx, obj)
 4446	})
 4447	if err != nil {
 4448		ec.Error(ctx, err)
 4449		return graphql.Null
 4450	}
 4451	if resTmp == nil {
 4452		if !graphql.HasFieldError(ctx, fc) {
 4453			ec.Errorf(ctx, "must not be null")
 4454		}
 4455		return graphql.Null
 4456	}
 4457	res := resTmp.(int)
 4458	fc.Result = res
 4459	return ec.marshalNInt2int(ctx, field.Selections, res)
 4460}
 4461
 4462func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4463	defer func() {
 4464		if r := recover(); r != nil {
 4465			ec.Error(ctx, ec.Recover(ctx, r))
 4466			ret = graphql.Null
 4467		}
 4468	}()
 4469	fc := &graphql.FieldContext{
 4470		Object:   "Color",
 4471		Field:    field,
 4472		Args:     nil,
 4473		IsMethod: true,
 4474	}
 4475
 4476	ctx = graphql.WithFieldContext(ctx, fc)
 4477	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4478		ctx = rctx // use context from middleware stack in children
 4479		return ec.resolvers.Color().B(rctx, obj)
 4480	})
 4481	if err != nil {
 4482		ec.Error(ctx, err)
 4483		return graphql.Null
 4484	}
 4485	if resTmp == nil {
 4486		if !graphql.HasFieldError(ctx, fc) {
 4487			ec.Errorf(ctx, "must not be null")
 4488		}
 4489		return graphql.Null
 4490	}
 4491	res := resTmp.(int)
 4492	fc.Result = res
 4493	return ec.marshalNInt2int(ctx, field.Selections, res)
 4494}
 4495
 4496func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4497	defer func() {
 4498		if r := recover(); r != nil {
 4499			ec.Error(ctx, ec.Recover(ctx, r))
 4500			ret = graphql.Null
 4501		}
 4502	}()
 4503	fc := &graphql.FieldContext{
 4504		Object:   "Comment",
 4505		Field:    field,
 4506		Args:     nil,
 4507		IsMethod: true,
 4508	}
 4509
 4510	ctx = graphql.WithFieldContext(ctx, fc)
 4511	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4512		ctx = rctx // use context from middleware stack in children
 4513		return ec.resolvers.Comment().Author(rctx, obj)
 4514	})
 4515	if err != nil {
 4516		ec.Error(ctx, err)
 4517		return graphql.Null
 4518	}
 4519	if resTmp == nil {
 4520		if !graphql.HasFieldError(ctx, fc) {
 4521			ec.Errorf(ctx, "must not be null")
 4522		}
 4523		return graphql.Null
 4524	}
 4525	res := resTmp.(models.IdentityWrapper)
 4526	fc.Result = res
 4527	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4528}
 4529
 4530func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4531	defer func() {
 4532		if r := recover(); r != nil {
 4533			ec.Error(ctx, ec.Recover(ctx, r))
 4534			ret = graphql.Null
 4535		}
 4536	}()
 4537	fc := &graphql.FieldContext{
 4538		Object:   "Comment",
 4539		Field:    field,
 4540		Args:     nil,
 4541		IsMethod: false,
 4542	}
 4543
 4544	ctx = graphql.WithFieldContext(ctx, fc)
 4545	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4546		ctx = rctx // use context from middleware stack in children
 4547		return obj.Message, nil
 4548	})
 4549	if err != nil {
 4550		ec.Error(ctx, err)
 4551		return graphql.Null
 4552	}
 4553	if resTmp == nil {
 4554		if !graphql.HasFieldError(ctx, fc) {
 4555			ec.Errorf(ctx, "must not be null")
 4556		}
 4557		return graphql.Null
 4558	}
 4559	res := resTmp.(string)
 4560	fc.Result = res
 4561	return ec.marshalNString2string(ctx, field.Selections, res)
 4562}
 4563
 4564func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4565	defer func() {
 4566		if r := recover(); r != nil {
 4567			ec.Error(ctx, ec.Recover(ctx, r))
 4568			ret = graphql.Null
 4569		}
 4570	}()
 4571	fc := &graphql.FieldContext{
 4572		Object:   "Comment",
 4573		Field:    field,
 4574		Args:     nil,
 4575		IsMethod: false,
 4576	}
 4577
 4578	ctx = graphql.WithFieldContext(ctx, fc)
 4579	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4580		ctx = rctx // use context from middleware stack in children
 4581		return obj.Files, nil
 4582	})
 4583	if err != nil {
 4584		ec.Error(ctx, err)
 4585		return graphql.Null
 4586	}
 4587	if resTmp == nil {
 4588		if !graphql.HasFieldError(ctx, fc) {
 4589			ec.Errorf(ctx, "must not be null")
 4590		}
 4591		return graphql.Null
 4592	}
 4593	res := resTmp.([]git.Hash)
 4594	fc.Result = res
 4595	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 4596}
 4597
 4598func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4599	defer func() {
 4600		if r := recover(); r != nil {
 4601			ec.Error(ctx, ec.Recover(ctx, r))
 4602			ret = graphql.Null
 4603		}
 4604	}()
 4605	fc := &graphql.FieldContext{
 4606		Object:   "CommentConnection",
 4607		Field:    field,
 4608		Args:     nil,
 4609		IsMethod: false,
 4610	}
 4611
 4612	ctx = graphql.WithFieldContext(ctx, fc)
 4613	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4614		ctx = rctx // use context from middleware stack in children
 4615		return obj.Edges, nil
 4616	})
 4617	if err != nil {
 4618		ec.Error(ctx, err)
 4619		return graphql.Null
 4620	}
 4621	if resTmp == nil {
 4622		if !graphql.HasFieldError(ctx, fc) {
 4623			ec.Errorf(ctx, "must not be null")
 4624		}
 4625		return graphql.Null
 4626	}
 4627	res := resTmp.([]*models.CommentEdge)
 4628	fc.Result = res
 4629	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4630}
 4631
 4632func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4633	defer func() {
 4634		if r := recover(); r != nil {
 4635			ec.Error(ctx, ec.Recover(ctx, r))
 4636			ret = graphql.Null
 4637		}
 4638	}()
 4639	fc := &graphql.FieldContext{
 4640		Object:   "CommentConnection",
 4641		Field:    field,
 4642		Args:     nil,
 4643		IsMethod: false,
 4644	}
 4645
 4646	ctx = graphql.WithFieldContext(ctx, fc)
 4647	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4648		ctx = rctx // use context from middleware stack in children
 4649		return obj.Nodes, nil
 4650	})
 4651	if err != nil {
 4652		ec.Error(ctx, err)
 4653		return graphql.Null
 4654	}
 4655	if resTmp == nil {
 4656		if !graphql.HasFieldError(ctx, fc) {
 4657			ec.Errorf(ctx, "must not be null")
 4658		}
 4659		return graphql.Null
 4660	}
 4661	res := resTmp.([]*bug.Comment)
 4662	fc.Result = res
 4663	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 4664}
 4665
 4666func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4667	defer func() {
 4668		if r := recover(); r != nil {
 4669			ec.Error(ctx, ec.Recover(ctx, r))
 4670			ret = graphql.Null
 4671		}
 4672	}()
 4673	fc := &graphql.FieldContext{
 4674		Object:   "CommentConnection",
 4675		Field:    field,
 4676		Args:     nil,
 4677		IsMethod: false,
 4678	}
 4679
 4680	ctx = graphql.WithFieldContext(ctx, fc)
 4681	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4682		ctx = rctx // use context from middleware stack in children
 4683		return obj.PageInfo, nil
 4684	})
 4685	if err != nil {
 4686		ec.Error(ctx, err)
 4687		return graphql.Null
 4688	}
 4689	if resTmp == nil {
 4690		if !graphql.HasFieldError(ctx, fc) {
 4691			ec.Errorf(ctx, "must not be null")
 4692		}
 4693		return graphql.Null
 4694	}
 4695	res := resTmp.(*models.PageInfo)
 4696	fc.Result = res
 4697	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4698}
 4699
 4700func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4701	defer func() {
 4702		if r := recover(); r != nil {
 4703			ec.Error(ctx, ec.Recover(ctx, r))
 4704			ret = graphql.Null
 4705		}
 4706	}()
 4707	fc := &graphql.FieldContext{
 4708		Object:   "CommentConnection",
 4709		Field:    field,
 4710		Args:     nil,
 4711		IsMethod: false,
 4712	}
 4713
 4714	ctx = graphql.WithFieldContext(ctx, fc)
 4715	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4716		ctx = rctx // use context from middleware stack in children
 4717		return obj.TotalCount, nil
 4718	})
 4719	if err != nil {
 4720		ec.Error(ctx, err)
 4721		return graphql.Null
 4722	}
 4723	if resTmp == nil {
 4724		if !graphql.HasFieldError(ctx, fc) {
 4725			ec.Errorf(ctx, "must not be null")
 4726		}
 4727		return graphql.Null
 4728	}
 4729	res := resTmp.(int)
 4730	fc.Result = res
 4731	return ec.marshalNInt2int(ctx, field.Selections, res)
 4732}
 4733
 4734func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4735	defer func() {
 4736		if r := recover(); r != nil {
 4737			ec.Error(ctx, ec.Recover(ctx, r))
 4738			ret = graphql.Null
 4739		}
 4740	}()
 4741	fc := &graphql.FieldContext{
 4742		Object:   "CommentEdge",
 4743		Field:    field,
 4744		Args:     nil,
 4745		IsMethod: false,
 4746	}
 4747
 4748	ctx = graphql.WithFieldContext(ctx, fc)
 4749	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4750		ctx = rctx // use context from middleware stack in children
 4751		return obj.Cursor, nil
 4752	})
 4753	if err != nil {
 4754		ec.Error(ctx, err)
 4755		return graphql.Null
 4756	}
 4757	if resTmp == nil {
 4758		if !graphql.HasFieldError(ctx, fc) {
 4759			ec.Errorf(ctx, "must not be null")
 4760		}
 4761		return graphql.Null
 4762	}
 4763	res := resTmp.(string)
 4764	fc.Result = res
 4765	return ec.marshalNString2string(ctx, field.Selections, res)
 4766}
 4767
 4768func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4769	defer func() {
 4770		if r := recover(); r != nil {
 4771			ec.Error(ctx, ec.Recover(ctx, r))
 4772			ret = graphql.Null
 4773		}
 4774	}()
 4775	fc := &graphql.FieldContext{
 4776		Object:   "CommentEdge",
 4777		Field:    field,
 4778		Args:     nil,
 4779		IsMethod: false,
 4780	}
 4781
 4782	ctx = graphql.WithFieldContext(ctx, fc)
 4783	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4784		ctx = rctx // use context from middleware stack in children
 4785		return obj.Node, nil
 4786	})
 4787	if err != nil {
 4788		ec.Error(ctx, err)
 4789		return graphql.Null
 4790	}
 4791	if resTmp == nil {
 4792		if !graphql.HasFieldError(ctx, fc) {
 4793			ec.Errorf(ctx, "must not be null")
 4794		}
 4795		return graphql.Null
 4796	}
 4797	res := resTmp.(*bug.Comment)
 4798	fc.Result = res
 4799	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4800}
 4801
 4802func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4803	defer func() {
 4804		if r := recover(); r != nil {
 4805			ec.Error(ctx, ec.Recover(ctx, r))
 4806			ret = graphql.Null
 4807		}
 4808	}()
 4809	fc := &graphql.FieldContext{
 4810		Object:   "CommentHistoryStep",
 4811		Field:    field,
 4812		Args:     nil,
 4813		IsMethod: false,
 4814	}
 4815
 4816	ctx = graphql.WithFieldContext(ctx, fc)
 4817	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4818		ctx = rctx // use context from middleware stack in children
 4819		return obj.Message, nil
 4820	})
 4821	if err != nil {
 4822		ec.Error(ctx, err)
 4823		return graphql.Null
 4824	}
 4825	if resTmp == nil {
 4826		if !graphql.HasFieldError(ctx, fc) {
 4827			ec.Errorf(ctx, "must not be null")
 4828		}
 4829		return graphql.Null
 4830	}
 4831	res := resTmp.(string)
 4832	fc.Result = res
 4833	return ec.marshalNString2string(ctx, field.Selections, res)
 4834}
 4835
 4836func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4837	defer func() {
 4838		if r := recover(); r != nil {
 4839			ec.Error(ctx, ec.Recover(ctx, r))
 4840			ret = graphql.Null
 4841		}
 4842	}()
 4843	fc := &graphql.FieldContext{
 4844		Object:   "CommentHistoryStep",
 4845		Field:    field,
 4846		Args:     nil,
 4847		IsMethod: true,
 4848	}
 4849
 4850	ctx = graphql.WithFieldContext(ctx, fc)
 4851	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4852		ctx = rctx // use context from middleware stack in children
 4853		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4854	})
 4855	if err != nil {
 4856		ec.Error(ctx, err)
 4857		return graphql.Null
 4858	}
 4859	if resTmp == nil {
 4860		if !graphql.HasFieldError(ctx, fc) {
 4861			ec.Errorf(ctx, "must not be null")
 4862		}
 4863		return graphql.Null
 4864	}
 4865	res := resTmp.(*time.Time)
 4866	fc.Result = res
 4867	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4868}
 4869
 4870func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4871	defer func() {
 4872		if r := recover(); r != nil {
 4873			ec.Error(ctx, ec.Recover(ctx, r))
 4874			ret = graphql.Null
 4875		}
 4876	}()
 4877	fc := &graphql.FieldContext{
 4878		Object:   "CreateOperation",
 4879		Field:    field,
 4880		Args:     nil,
 4881		IsMethod: true,
 4882	}
 4883
 4884	ctx = graphql.WithFieldContext(ctx, fc)
 4885	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4886		ctx = rctx // use context from middleware stack in children
 4887		return ec.resolvers.CreateOperation().ID(rctx, obj)
 4888	})
 4889	if err != nil {
 4890		ec.Error(ctx, err)
 4891		return graphql.Null
 4892	}
 4893	if resTmp == nil {
 4894		if !graphql.HasFieldError(ctx, fc) {
 4895			ec.Errorf(ctx, "must not be null")
 4896		}
 4897		return graphql.Null
 4898	}
 4899	res := resTmp.(string)
 4900	fc.Result = res
 4901	return ec.marshalNString2string(ctx, field.Selections, res)
 4902}
 4903
 4904func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4905	defer func() {
 4906		if r := recover(); r != nil {
 4907			ec.Error(ctx, ec.Recover(ctx, r))
 4908			ret = graphql.Null
 4909		}
 4910	}()
 4911	fc := &graphql.FieldContext{
 4912		Object:   "CreateOperation",
 4913		Field:    field,
 4914		Args:     nil,
 4915		IsMethod: true,
 4916	}
 4917
 4918	ctx = graphql.WithFieldContext(ctx, fc)
 4919	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4920		ctx = rctx // use context from middleware stack in children
 4921		return ec.resolvers.CreateOperation().Author(rctx, obj)
 4922	})
 4923	if err != nil {
 4924		ec.Error(ctx, err)
 4925		return graphql.Null
 4926	}
 4927	if resTmp == nil {
 4928		if !graphql.HasFieldError(ctx, fc) {
 4929			ec.Errorf(ctx, "must not be null")
 4930		}
 4931		return graphql.Null
 4932	}
 4933	res := resTmp.(models.IdentityWrapper)
 4934	fc.Result = res
 4935	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4936}
 4937
 4938func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4939	defer func() {
 4940		if r := recover(); r != nil {
 4941			ec.Error(ctx, ec.Recover(ctx, r))
 4942			ret = graphql.Null
 4943		}
 4944	}()
 4945	fc := &graphql.FieldContext{
 4946		Object:   "CreateOperation",
 4947		Field:    field,
 4948		Args:     nil,
 4949		IsMethod: true,
 4950	}
 4951
 4952	ctx = graphql.WithFieldContext(ctx, fc)
 4953	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4954		ctx = rctx // use context from middleware stack in children
 4955		return ec.resolvers.CreateOperation().Date(rctx, obj)
 4956	})
 4957	if err != nil {
 4958		ec.Error(ctx, err)
 4959		return graphql.Null
 4960	}
 4961	if resTmp == nil {
 4962		if !graphql.HasFieldError(ctx, fc) {
 4963			ec.Errorf(ctx, "must not be null")
 4964		}
 4965		return graphql.Null
 4966	}
 4967	res := resTmp.(*time.Time)
 4968	fc.Result = res
 4969	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4970}
 4971
 4972func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4973	defer func() {
 4974		if r := recover(); r != nil {
 4975			ec.Error(ctx, ec.Recover(ctx, r))
 4976			ret = graphql.Null
 4977		}
 4978	}()
 4979	fc := &graphql.FieldContext{
 4980		Object:   "CreateOperation",
 4981		Field:    field,
 4982		Args:     nil,
 4983		IsMethod: false,
 4984	}
 4985
 4986	ctx = graphql.WithFieldContext(ctx, fc)
 4987	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4988		ctx = rctx // use context from middleware stack in children
 4989		return obj.Title, nil
 4990	})
 4991	if err != nil {
 4992		ec.Error(ctx, err)
 4993		return graphql.Null
 4994	}
 4995	if resTmp == nil {
 4996		if !graphql.HasFieldError(ctx, fc) {
 4997			ec.Errorf(ctx, "must not be null")
 4998		}
 4999		return graphql.Null
 5000	}
 5001	res := resTmp.(string)
 5002	fc.Result = res
 5003	return ec.marshalNString2string(ctx, field.Selections, res)
 5004}
 5005
 5006func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5007	defer func() {
 5008		if r := recover(); r != nil {
 5009			ec.Error(ctx, ec.Recover(ctx, r))
 5010			ret = graphql.Null
 5011		}
 5012	}()
 5013	fc := &graphql.FieldContext{
 5014		Object:   "CreateOperation",
 5015		Field:    field,
 5016		Args:     nil,
 5017		IsMethod: false,
 5018	}
 5019
 5020	ctx = graphql.WithFieldContext(ctx, fc)
 5021	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5022		ctx = rctx // use context from middleware stack in children
 5023		return obj.Message, nil
 5024	})
 5025	if err != nil {
 5026		ec.Error(ctx, err)
 5027		return graphql.Null
 5028	}
 5029	if resTmp == nil {
 5030		if !graphql.HasFieldError(ctx, fc) {
 5031			ec.Errorf(ctx, "must not be null")
 5032		}
 5033		return graphql.Null
 5034	}
 5035	res := resTmp.(string)
 5036	fc.Result = res
 5037	return ec.marshalNString2string(ctx, field.Selections, res)
 5038}
 5039
 5040func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5041	defer func() {
 5042		if r := recover(); r != nil {
 5043			ec.Error(ctx, ec.Recover(ctx, r))
 5044			ret = graphql.Null
 5045		}
 5046	}()
 5047	fc := &graphql.FieldContext{
 5048		Object:   "CreateOperation",
 5049		Field:    field,
 5050		Args:     nil,
 5051		IsMethod: false,
 5052	}
 5053
 5054	ctx = graphql.WithFieldContext(ctx, fc)
 5055	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5056		ctx = rctx // use context from middleware stack in children
 5057		return obj.Files, nil
 5058	})
 5059	if err != nil {
 5060		ec.Error(ctx, err)
 5061		return graphql.Null
 5062	}
 5063	if resTmp == nil {
 5064		if !graphql.HasFieldError(ctx, fc) {
 5065			ec.Errorf(ctx, "must not be null")
 5066		}
 5067		return graphql.Null
 5068	}
 5069	res := resTmp.([]git.Hash)
 5070	fc.Result = res
 5071	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5072}
 5073
 5074func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5075	defer func() {
 5076		if r := recover(); r != nil {
 5077			ec.Error(ctx, ec.Recover(ctx, r))
 5078			ret = graphql.Null
 5079		}
 5080	}()
 5081	fc := &graphql.FieldContext{
 5082		Object:   "CreateTimelineItem",
 5083		Field:    field,
 5084		Args:     nil,
 5085		IsMethod: true,
 5086	}
 5087
 5088	ctx = graphql.WithFieldContext(ctx, fc)
 5089	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5090		ctx = rctx // use context from middleware stack in children
 5091		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5092	})
 5093	if err != nil {
 5094		ec.Error(ctx, err)
 5095		return graphql.Null
 5096	}
 5097	if resTmp == nil {
 5098		if !graphql.HasFieldError(ctx, fc) {
 5099			ec.Errorf(ctx, "must not be null")
 5100		}
 5101		return graphql.Null
 5102	}
 5103	res := resTmp.(string)
 5104	fc.Result = res
 5105	return ec.marshalNString2string(ctx, field.Selections, res)
 5106}
 5107
 5108func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5109	defer func() {
 5110		if r := recover(); r != nil {
 5111			ec.Error(ctx, ec.Recover(ctx, r))
 5112			ret = graphql.Null
 5113		}
 5114	}()
 5115	fc := &graphql.FieldContext{
 5116		Object:   "CreateTimelineItem",
 5117		Field:    field,
 5118		Args:     nil,
 5119		IsMethod: true,
 5120	}
 5121
 5122	ctx = graphql.WithFieldContext(ctx, fc)
 5123	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5124		ctx = rctx // use context from middleware stack in children
 5125		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
 5126	})
 5127	if err != nil {
 5128		ec.Error(ctx, err)
 5129		return graphql.Null
 5130	}
 5131	if resTmp == nil {
 5132		if !graphql.HasFieldError(ctx, fc) {
 5133			ec.Errorf(ctx, "must not be null")
 5134		}
 5135		return graphql.Null
 5136	}
 5137	res := resTmp.(models.IdentityWrapper)
 5138	fc.Result = res
 5139	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5140}
 5141
 5142func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5143	defer func() {
 5144		if r := recover(); r != nil {
 5145			ec.Error(ctx, ec.Recover(ctx, r))
 5146			ret = graphql.Null
 5147		}
 5148	}()
 5149	fc := &graphql.FieldContext{
 5150		Object:   "CreateTimelineItem",
 5151		Field:    field,
 5152		Args:     nil,
 5153		IsMethod: false,
 5154	}
 5155
 5156	ctx = graphql.WithFieldContext(ctx, fc)
 5157	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5158		ctx = rctx // use context from middleware stack in children
 5159		return obj.Message, nil
 5160	})
 5161	if err != nil {
 5162		ec.Error(ctx, err)
 5163		return graphql.Null
 5164	}
 5165	if resTmp == nil {
 5166		if !graphql.HasFieldError(ctx, fc) {
 5167			ec.Errorf(ctx, "must not be null")
 5168		}
 5169		return graphql.Null
 5170	}
 5171	res := resTmp.(string)
 5172	fc.Result = res
 5173	return ec.marshalNString2string(ctx, field.Selections, res)
 5174}
 5175
 5176func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5177	defer func() {
 5178		if r := recover(); r != nil {
 5179			ec.Error(ctx, ec.Recover(ctx, r))
 5180			ret = graphql.Null
 5181		}
 5182	}()
 5183	fc := &graphql.FieldContext{
 5184		Object:   "CreateTimelineItem",
 5185		Field:    field,
 5186		Args:     nil,
 5187		IsMethod: true,
 5188	}
 5189
 5190	ctx = graphql.WithFieldContext(ctx, fc)
 5191	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5192		ctx = rctx // use context from middleware stack in children
 5193		return obj.MessageIsEmpty(), nil
 5194	})
 5195	if err != nil {
 5196		ec.Error(ctx, err)
 5197		return graphql.Null
 5198	}
 5199	if resTmp == nil {
 5200		if !graphql.HasFieldError(ctx, fc) {
 5201			ec.Errorf(ctx, "must not be null")
 5202		}
 5203		return graphql.Null
 5204	}
 5205	res := resTmp.(bool)
 5206	fc.Result = res
 5207	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5208}
 5209
 5210func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5211	defer func() {
 5212		if r := recover(); r != nil {
 5213			ec.Error(ctx, ec.Recover(ctx, r))
 5214			ret = graphql.Null
 5215		}
 5216	}()
 5217	fc := &graphql.FieldContext{
 5218		Object:   "CreateTimelineItem",
 5219		Field:    field,
 5220		Args:     nil,
 5221		IsMethod: false,
 5222	}
 5223
 5224	ctx = graphql.WithFieldContext(ctx, fc)
 5225	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5226		ctx = rctx // use context from middleware stack in children
 5227		return obj.Files, nil
 5228	})
 5229	if err != nil {
 5230		ec.Error(ctx, err)
 5231		return graphql.Null
 5232	}
 5233	if resTmp == nil {
 5234		if !graphql.HasFieldError(ctx, fc) {
 5235			ec.Errorf(ctx, "must not be null")
 5236		}
 5237		return graphql.Null
 5238	}
 5239	res := resTmp.([]git.Hash)
 5240	fc.Result = res
 5241	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5242}
 5243
 5244func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5245	defer func() {
 5246		if r := recover(); r != nil {
 5247			ec.Error(ctx, ec.Recover(ctx, r))
 5248			ret = graphql.Null
 5249		}
 5250	}()
 5251	fc := &graphql.FieldContext{
 5252		Object:   "CreateTimelineItem",
 5253		Field:    field,
 5254		Args:     nil,
 5255		IsMethod: true,
 5256	}
 5257
 5258	ctx = graphql.WithFieldContext(ctx, fc)
 5259	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5260		ctx = rctx // use context from middleware stack in children
 5261		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5262	})
 5263	if err != nil {
 5264		ec.Error(ctx, err)
 5265		return graphql.Null
 5266	}
 5267	if resTmp == nil {
 5268		if !graphql.HasFieldError(ctx, fc) {
 5269			ec.Errorf(ctx, "must not be null")
 5270		}
 5271		return graphql.Null
 5272	}
 5273	res := resTmp.(*time.Time)
 5274	fc.Result = res
 5275	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5276}
 5277
 5278func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5279	defer func() {
 5280		if r := recover(); r != nil {
 5281			ec.Error(ctx, ec.Recover(ctx, r))
 5282			ret = graphql.Null
 5283		}
 5284	}()
 5285	fc := &graphql.FieldContext{
 5286		Object:   "CreateTimelineItem",
 5287		Field:    field,
 5288		Args:     nil,
 5289		IsMethod: true,
 5290	}
 5291
 5292	ctx = graphql.WithFieldContext(ctx, fc)
 5293	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5294		ctx = rctx // use context from middleware stack in children
 5295		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5296	})
 5297	if err != nil {
 5298		ec.Error(ctx, err)
 5299		return graphql.Null
 5300	}
 5301	if resTmp == nil {
 5302		if !graphql.HasFieldError(ctx, fc) {
 5303			ec.Errorf(ctx, "must not be null")
 5304		}
 5305		return graphql.Null
 5306	}
 5307	res := resTmp.(*time.Time)
 5308	fc.Result = res
 5309	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5310}
 5311
 5312func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5313	defer func() {
 5314		if r := recover(); r != nil {
 5315			ec.Error(ctx, ec.Recover(ctx, r))
 5316			ret = graphql.Null
 5317		}
 5318	}()
 5319	fc := &graphql.FieldContext{
 5320		Object:   "CreateTimelineItem",
 5321		Field:    field,
 5322		Args:     nil,
 5323		IsMethod: true,
 5324	}
 5325
 5326	ctx = graphql.WithFieldContext(ctx, fc)
 5327	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5328		ctx = rctx // use context from middleware stack in children
 5329		return obj.Edited(), nil
 5330	})
 5331	if err != nil {
 5332		ec.Error(ctx, err)
 5333		return graphql.Null
 5334	}
 5335	if resTmp == nil {
 5336		if !graphql.HasFieldError(ctx, fc) {
 5337			ec.Errorf(ctx, "must not be null")
 5338		}
 5339		return graphql.Null
 5340	}
 5341	res := resTmp.(bool)
 5342	fc.Result = res
 5343	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5344}
 5345
 5346func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5347	defer func() {
 5348		if r := recover(); r != nil {
 5349			ec.Error(ctx, ec.Recover(ctx, r))
 5350			ret = graphql.Null
 5351		}
 5352	}()
 5353	fc := &graphql.FieldContext{
 5354		Object:   "CreateTimelineItem",
 5355		Field:    field,
 5356		Args:     nil,
 5357		IsMethod: false,
 5358	}
 5359
 5360	ctx = graphql.WithFieldContext(ctx, fc)
 5361	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5362		ctx = rctx // use context from middleware stack in children
 5363		return obj.History, nil
 5364	})
 5365	if err != nil {
 5366		ec.Error(ctx, err)
 5367		return graphql.Null
 5368	}
 5369	if resTmp == nil {
 5370		if !graphql.HasFieldError(ctx, fc) {
 5371			ec.Errorf(ctx, "must not be null")
 5372		}
 5373		return graphql.Null
 5374	}
 5375	res := resTmp.([]bug.CommentHistoryStep)
 5376	fc.Result = res
 5377	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5378}
 5379
 5380func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5381	defer func() {
 5382		if r := recover(); r != nil {
 5383			ec.Error(ctx, ec.Recover(ctx, r))
 5384			ret = graphql.Null
 5385		}
 5386	}()
 5387	fc := &graphql.FieldContext{
 5388		Object:   "EditCommentOperation",
 5389		Field:    field,
 5390		Args:     nil,
 5391		IsMethod: true,
 5392	}
 5393
 5394	ctx = graphql.WithFieldContext(ctx, fc)
 5395	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5396		ctx = rctx // use context from middleware stack in children
 5397		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5398	})
 5399	if err != nil {
 5400		ec.Error(ctx, err)
 5401		return graphql.Null
 5402	}
 5403	if resTmp == nil {
 5404		if !graphql.HasFieldError(ctx, fc) {
 5405			ec.Errorf(ctx, "must not be null")
 5406		}
 5407		return graphql.Null
 5408	}
 5409	res := resTmp.(string)
 5410	fc.Result = res
 5411	return ec.marshalNString2string(ctx, field.Selections, res)
 5412}
 5413
 5414func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5415	defer func() {
 5416		if r := recover(); r != nil {
 5417			ec.Error(ctx, ec.Recover(ctx, r))
 5418			ret = graphql.Null
 5419		}
 5420	}()
 5421	fc := &graphql.FieldContext{
 5422		Object:   "EditCommentOperation",
 5423		Field:    field,
 5424		Args:     nil,
 5425		IsMethod: true,
 5426	}
 5427
 5428	ctx = graphql.WithFieldContext(ctx, fc)
 5429	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5430		ctx = rctx // use context from middleware stack in children
 5431		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
 5432	})
 5433	if err != nil {
 5434		ec.Error(ctx, err)
 5435		return graphql.Null
 5436	}
 5437	if resTmp == nil {
 5438		if !graphql.HasFieldError(ctx, fc) {
 5439			ec.Errorf(ctx, "must not be null")
 5440		}
 5441		return graphql.Null
 5442	}
 5443	res := resTmp.(models.IdentityWrapper)
 5444	fc.Result = res
 5445	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5446}
 5447
 5448func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5449	defer func() {
 5450		if r := recover(); r != nil {
 5451			ec.Error(ctx, ec.Recover(ctx, r))
 5452			ret = graphql.Null
 5453		}
 5454	}()
 5455	fc := &graphql.FieldContext{
 5456		Object:   "EditCommentOperation",
 5457		Field:    field,
 5458		Args:     nil,
 5459		IsMethod: true,
 5460	}
 5461
 5462	ctx = graphql.WithFieldContext(ctx, fc)
 5463	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5464		ctx = rctx // use context from middleware stack in children
 5465		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5466	})
 5467	if err != nil {
 5468		ec.Error(ctx, err)
 5469		return graphql.Null
 5470	}
 5471	if resTmp == nil {
 5472		if !graphql.HasFieldError(ctx, fc) {
 5473			ec.Errorf(ctx, "must not be null")
 5474		}
 5475		return graphql.Null
 5476	}
 5477	res := resTmp.(*time.Time)
 5478	fc.Result = res
 5479	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5480}
 5481
 5482func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5483	defer func() {
 5484		if r := recover(); r != nil {
 5485			ec.Error(ctx, ec.Recover(ctx, r))
 5486			ret = graphql.Null
 5487		}
 5488	}()
 5489	fc := &graphql.FieldContext{
 5490		Object:   "EditCommentOperation",
 5491		Field:    field,
 5492		Args:     nil,
 5493		IsMethod: true,
 5494	}
 5495
 5496	ctx = graphql.WithFieldContext(ctx, fc)
 5497	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5498		ctx = rctx // use context from middleware stack in children
 5499		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5500	})
 5501	if err != nil {
 5502		ec.Error(ctx, err)
 5503		return graphql.Null
 5504	}
 5505	if resTmp == nil {
 5506		if !graphql.HasFieldError(ctx, fc) {
 5507			ec.Errorf(ctx, "must not be null")
 5508		}
 5509		return graphql.Null
 5510	}
 5511	res := resTmp.(string)
 5512	fc.Result = res
 5513	return ec.marshalNString2string(ctx, field.Selections, res)
 5514}
 5515
 5516func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5517	defer func() {
 5518		if r := recover(); r != nil {
 5519			ec.Error(ctx, ec.Recover(ctx, r))
 5520			ret = graphql.Null
 5521		}
 5522	}()
 5523	fc := &graphql.FieldContext{
 5524		Object:   "EditCommentOperation",
 5525		Field:    field,
 5526		Args:     nil,
 5527		IsMethod: false,
 5528	}
 5529
 5530	ctx = graphql.WithFieldContext(ctx, fc)
 5531	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5532		ctx = rctx // use context from middleware stack in children
 5533		return obj.Message, nil
 5534	})
 5535	if err != nil {
 5536		ec.Error(ctx, err)
 5537		return graphql.Null
 5538	}
 5539	if resTmp == nil {
 5540		if !graphql.HasFieldError(ctx, fc) {
 5541			ec.Errorf(ctx, "must not be null")
 5542		}
 5543		return graphql.Null
 5544	}
 5545	res := resTmp.(string)
 5546	fc.Result = res
 5547	return ec.marshalNString2string(ctx, field.Selections, res)
 5548}
 5549
 5550func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5551	defer func() {
 5552		if r := recover(); r != nil {
 5553			ec.Error(ctx, ec.Recover(ctx, r))
 5554			ret = graphql.Null
 5555		}
 5556	}()
 5557	fc := &graphql.FieldContext{
 5558		Object:   "EditCommentOperation",
 5559		Field:    field,
 5560		Args:     nil,
 5561		IsMethod: false,
 5562	}
 5563
 5564	ctx = graphql.WithFieldContext(ctx, fc)
 5565	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5566		ctx = rctx // use context from middleware stack in children
 5567		return obj.Files, nil
 5568	})
 5569	if err != nil {
 5570		ec.Error(ctx, err)
 5571		return graphql.Null
 5572	}
 5573	if resTmp == nil {
 5574		if !graphql.HasFieldError(ctx, fc) {
 5575			ec.Errorf(ctx, "must not be null")
 5576		}
 5577		return graphql.Null
 5578	}
 5579	res := resTmp.([]git.Hash)
 5580	fc.Result = res
 5581	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5582}
 5583
 5584func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5585	defer func() {
 5586		if r := recover(); r != nil {
 5587			ec.Error(ctx, ec.Recover(ctx, r))
 5588			ret = graphql.Null
 5589		}
 5590	}()
 5591	fc := &graphql.FieldContext{
 5592		Object:   "Identity",
 5593		Field:    field,
 5594		Args:     nil,
 5595		IsMethod: true,
 5596	}
 5597
 5598	ctx = graphql.WithFieldContext(ctx, fc)
 5599	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5600		ctx = rctx // use context from middleware stack in children
 5601		return ec.resolvers.Identity().ID(rctx, obj)
 5602	})
 5603	if err != nil {
 5604		ec.Error(ctx, err)
 5605		return graphql.Null
 5606	}
 5607	if resTmp == nil {
 5608		if !graphql.HasFieldError(ctx, fc) {
 5609			ec.Errorf(ctx, "must not be null")
 5610		}
 5611		return graphql.Null
 5612	}
 5613	res := resTmp.(string)
 5614	fc.Result = res
 5615	return ec.marshalNString2string(ctx, field.Selections, res)
 5616}
 5617
 5618func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5619	defer func() {
 5620		if r := recover(); r != nil {
 5621			ec.Error(ctx, ec.Recover(ctx, r))
 5622			ret = graphql.Null
 5623		}
 5624	}()
 5625	fc := &graphql.FieldContext{
 5626		Object:   "Identity",
 5627		Field:    field,
 5628		Args:     nil,
 5629		IsMethod: true,
 5630	}
 5631
 5632	ctx = graphql.WithFieldContext(ctx, fc)
 5633	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5634		ctx = rctx // use context from middleware stack in children
 5635		return ec.resolvers.Identity().HumanID(rctx, obj)
 5636	})
 5637	if err != nil {
 5638		ec.Error(ctx, err)
 5639		return graphql.Null
 5640	}
 5641	if resTmp == nil {
 5642		if !graphql.HasFieldError(ctx, fc) {
 5643			ec.Errorf(ctx, "must not be null")
 5644		}
 5645		return graphql.Null
 5646	}
 5647	res := resTmp.(string)
 5648	fc.Result = res
 5649	return ec.marshalNString2string(ctx, field.Selections, res)
 5650}
 5651
 5652func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5653	defer func() {
 5654		if r := recover(); r != nil {
 5655			ec.Error(ctx, ec.Recover(ctx, r))
 5656			ret = graphql.Null
 5657		}
 5658	}()
 5659	fc := &graphql.FieldContext{
 5660		Object:   "Identity",
 5661		Field:    field,
 5662		Args:     nil,
 5663		IsMethod: true,
 5664	}
 5665
 5666	ctx = graphql.WithFieldContext(ctx, fc)
 5667	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5668		ctx = rctx // use context from middleware stack in children
 5669		return obj.Name(), nil
 5670	})
 5671	if err != nil {
 5672		ec.Error(ctx, err)
 5673		return graphql.Null
 5674	}
 5675	if resTmp == nil {
 5676		return graphql.Null
 5677	}
 5678	res := resTmp.(string)
 5679	fc.Result = res
 5680	return ec.marshalOString2string(ctx, field.Selections, res)
 5681}
 5682
 5683func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5684	defer func() {
 5685		if r := recover(); r != nil {
 5686			ec.Error(ctx, ec.Recover(ctx, r))
 5687			ret = graphql.Null
 5688		}
 5689	}()
 5690	fc := &graphql.FieldContext{
 5691		Object:   "Identity",
 5692		Field:    field,
 5693		Args:     nil,
 5694		IsMethod: true,
 5695	}
 5696
 5697	ctx = graphql.WithFieldContext(ctx, fc)
 5698	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5699		ctx = rctx // use context from middleware stack in children
 5700		return obj.Email()
 5701	})
 5702	if err != nil {
 5703		ec.Error(ctx, err)
 5704		return graphql.Null
 5705	}
 5706	if resTmp == nil {
 5707		return graphql.Null
 5708	}
 5709	res := resTmp.(string)
 5710	fc.Result = res
 5711	return ec.marshalOString2string(ctx, field.Selections, res)
 5712}
 5713
 5714func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5715	defer func() {
 5716		if r := recover(); r != nil {
 5717			ec.Error(ctx, ec.Recover(ctx, r))
 5718			ret = graphql.Null
 5719		}
 5720	}()
 5721	fc := &graphql.FieldContext{
 5722		Object:   "Identity",
 5723		Field:    field,
 5724		Args:     nil,
 5725		IsMethod: true,
 5726	}
 5727
 5728	ctx = graphql.WithFieldContext(ctx, fc)
 5729	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5730		ctx = rctx // use context from middleware stack in children
 5731		return obj.DisplayName(), nil
 5732	})
 5733	if err != nil {
 5734		ec.Error(ctx, err)
 5735		return graphql.Null
 5736	}
 5737	if resTmp == nil {
 5738		if !graphql.HasFieldError(ctx, fc) {
 5739			ec.Errorf(ctx, "must not be null")
 5740		}
 5741		return graphql.Null
 5742	}
 5743	res := resTmp.(string)
 5744	fc.Result = res
 5745	return ec.marshalNString2string(ctx, field.Selections, res)
 5746}
 5747
 5748func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5749	defer func() {
 5750		if r := recover(); r != nil {
 5751			ec.Error(ctx, ec.Recover(ctx, r))
 5752			ret = graphql.Null
 5753		}
 5754	}()
 5755	fc := &graphql.FieldContext{
 5756		Object:   "Identity",
 5757		Field:    field,
 5758		Args:     nil,
 5759		IsMethod: true,
 5760	}
 5761
 5762	ctx = graphql.WithFieldContext(ctx, fc)
 5763	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5764		ctx = rctx // use context from middleware stack in children
 5765		return obj.AvatarUrl()
 5766	})
 5767	if err != nil {
 5768		ec.Error(ctx, err)
 5769		return graphql.Null
 5770	}
 5771	if resTmp == nil {
 5772		return graphql.Null
 5773	}
 5774	res := resTmp.(string)
 5775	fc.Result = res
 5776	return ec.marshalOString2string(ctx, field.Selections, res)
 5777}
 5778
 5779func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5780	defer func() {
 5781		if r := recover(); r != nil {
 5782			ec.Error(ctx, ec.Recover(ctx, r))
 5783			ret = graphql.Null
 5784		}
 5785	}()
 5786	fc := &graphql.FieldContext{
 5787		Object:   "Identity",
 5788		Field:    field,
 5789		Args:     nil,
 5790		IsMethod: true,
 5791	}
 5792
 5793	ctx = graphql.WithFieldContext(ctx, fc)
 5794	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5795		ctx = rctx // use context from middleware stack in children
 5796		return obj.IsProtected()
 5797	})
 5798	if err != nil {
 5799		ec.Error(ctx, err)
 5800		return graphql.Null
 5801	}
 5802	if resTmp == nil {
 5803		if !graphql.HasFieldError(ctx, fc) {
 5804			ec.Errorf(ctx, "must not be null")
 5805		}
 5806		return graphql.Null
 5807	}
 5808	res := resTmp.(bool)
 5809	fc.Result = res
 5810	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5811}
 5812
 5813func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5814	defer func() {
 5815		if r := recover(); r != nil {
 5816			ec.Error(ctx, ec.Recover(ctx, r))
 5817			ret = graphql.Null
 5818		}
 5819	}()
 5820	fc := &graphql.FieldContext{
 5821		Object:   "IdentityConnection",
 5822		Field:    field,
 5823		Args:     nil,
 5824		IsMethod: false,
 5825	}
 5826
 5827	ctx = graphql.WithFieldContext(ctx, fc)
 5828	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5829		ctx = rctx // use context from middleware stack in children
 5830		return obj.Edges, nil
 5831	})
 5832	if err != nil {
 5833		ec.Error(ctx, err)
 5834		return graphql.Null
 5835	}
 5836	if resTmp == nil {
 5837		if !graphql.HasFieldError(ctx, fc) {
 5838			ec.Errorf(ctx, "must not be null")
 5839		}
 5840		return graphql.Null
 5841	}
 5842	res := resTmp.([]*models.IdentityEdge)
 5843	fc.Result = res
 5844	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 5845}
 5846
 5847func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5848	defer func() {
 5849		if r := recover(); r != nil {
 5850			ec.Error(ctx, ec.Recover(ctx, r))
 5851			ret = graphql.Null
 5852		}
 5853	}()
 5854	fc := &graphql.FieldContext{
 5855		Object:   "IdentityConnection",
 5856		Field:    field,
 5857		Args:     nil,
 5858		IsMethod: false,
 5859	}
 5860
 5861	ctx = graphql.WithFieldContext(ctx, fc)
 5862	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5863		ctx = rctx // use context from middleware stack in children
 5864		return obj.Nodes, nil
 5865	})
 5866	if err != nil {
 5867		ec.Error(ctx, err)
 5868		return graphql.Null
 5869	}
 5870	if resTmp == nil {
 5871		if !graphql.HasFieldError(ctx, fc) {
 5872			ec.Errorf(ctx, "must not be null")
 5873		}
 5874		return graphql.Null
 5875	}
 5876	res := resTmp.([]models.IdentityWrapper)
 5877	fc.Result = res
 5878	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
 5879}
 5880
 5881func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5882	defer func() {
 5883		if r := recover(); r != nil {
 5884			ec.Error(ctx, ec.Recover(ctx, r))
 5885			ret = graphql.Null
 5886		}
 5887	}()
 5888	fc := &graphql.FieldContext{
 5889		Object:   "IdentityConnection",
 5890		Field:    field,
 5891		Args:     nil,
 5892		IsMethod: false,
 5893	}
 5894
 5895	ctx = graphql.WithFieldContext(ctx, fc)
 5896	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5897		ctx = rctx // use context from middleware stack in children
 5898		return obj.PageInfo, nil
 5899	})
 5900	if err != nil {
 5901		ec.Error(ctx, err)
 5902		return graphql.Null
 5903	}
 5904	if resTmp == nil {
 5905		if !graphql.HasFieldError(ctx, fc) {
 5906			ec.Errorf(ctx, "must not be null")
 5907		}
 5908		return graphql.Null
 5909	}
 5910	res := resTmp.(*models.PageInfo)
 5911	fc.Result = res
 5912	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 5913}
 5914
 5915func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 5916	defer func() {
 5917		if r := recover(); r != nil {
 5918			ec.Error(ctx, ec.Recover(ctx, r))
 5919			ret = graphql.Null
 5920		}
 5921	}()
 5922	fc := &graphql.FieldContext{
 5923		Object:   "IdentityConnection",
 5924		Field:    field,
 5925		Args:     nil,
 5926		IsMethod: false,
 5927	}
 5928
 5929	ctx = graphql.WithFieldContext(ctx, fc)
 5930	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5931		ctx = rctx // use context from middleware stack in children
 5932		return obj.TotalCount, nil
 5933	})
 5934	if err != nil {
 5935		ec.Error(ctx, err)
 5936		return graphql.Null
 5937	}
 5938	if resTmp == nil {
 5939		if !graphql.HasFieldError(ctx, fc) {
 5940			ec.Errorf(ctx, "must not be null")
 5941		}
 5942		return graphql.Null
 5943	}
 5944	res := resTmp.(int)
 5945	fc.Result = res
 5946	return ec.marshalNInt2int(ctx, field.Selections, res)
 5947}
 5948
 5949func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 5950	defer func() {
 5951		if r := recover(); r != nil {
 5952			ec.Error(ctx, ec.Recover(ctx, r))
 5953			ret = graphql.Null
 5954		}
 5955	}()
 5956	fc := &graphql.FieldContext{
 5957		Object:   "IdentityEdge",
 5958		Field:    field,
 5959		Args:     nil,
 5960		IsMethod: false,
 5961	}
 5962
 5963	ctx = graphql.WithFieldContext(ctx, fc)
 5964	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5965		ctx = rctx // use context from middleware stack in children
 5966		return obj.Cursor, nil
 5967	})
 5968	if err != nil {
 5969		ec.Error(ctx, err)
 5970		return graphql.Null
 5971	}
 5972	if resTmp == nil {
 5973		if !graphql.HasFieldError(ctx, fc) {
 5974			ec.Errorf(ctx, "must not be null")
 5975		}
 5976		return graphql.Null
 5977	}
 5978	res := resTmp.(string)
 5979	fc.Result = res
 5980	return ec.marshalNString2string(ctx, field.Selections, res)
 5981}
 5982
 5983func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 5984	defer func() {
 5985		if r := recover(); r != nil {
 5986			ec.Error(ctx, ec.Recover(ctx, r))
 5987			ret = graphql.Null
 5988		}
 5989	}()
 5990	fc := &graphql.FieldContext{
 5991		Object:   "IdentityEdge",
 5992		Field:    field,
 5993		Args:     nil,
 5994		IsMethod: false,
 5995	}
 5996
 5997	ctx = graphql.WithFieldContext(ctx, fc)
 5998	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5999		ctx = rctx // use context from middleware stack in children
 6000		return obj.Node, nil
 6001	})
 6002	if err != nil {
 6003		ec.Error(ctx, err)
 6004		return graphql.Null
 6005	}
 6006	if resTmp == nil {
 6007		if !graphql.HasFieldError(ctx, fc) {
 6008			ec.Errorf(ctx, "must not be null")
 6009		}
 6010		return graphql.Null
 6011	}
 6012	res := resTmp.(models.IdentityWrapper)
 6013	fc.Result = res
 6014	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6015}
 6016
 6017func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6018	defer func() {
 6019		if r := recover(); r != nil {
 6020			ec.Error(ctx, ec.Recover(ctx, r))
 6021			ret = graphql.Null
 6022		}
 6023	}()
 6024	fc := &graphql.FieldContext{
 6025		Object:   "Label",
 6026		Field:    field,
 6027		Args:     nil,
 6028		IsMethod: true,
 6029	}
 6030
 6031	ctx = graphql.WithFieldContext(ctx, fc)
 6032	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6033		ctx = rctx // use context from middleware stack in children
 6034		return ec.resolvers.Label().Name(rctx, obj)
 6035	})
 6036	if err != nil {
 6037		ec.Error(ctx, err)
 6038		return graphql.Null
 6039	}
 6040	if resTmp == nil {
 6041		if !graphql.HasFieldError(ctx, fc) {
 6042			ec.Errorf(ctx, "must not be null")
 6043		}
 6044		return graphql.Null
 6045	}
 6046	res := resTmp.(string)
 6047	fc.Result = res
 6048	return ec.marshalNString2string(ctx, field.Selections, res)
 6049}
 6050
 6051func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6052	defer func() {
 6053		if r := recover(); r != nil {
 6054			ec.Error(ctx, ec.Recover(ctx, r))
 6055			ret = graphql.Null
 6056		}
 6057	}()
 6058	fc := &graphql.FieldContext{
 6059		Object:   "Label",
 6060		Field:    field,
 6061		Args:     nil,
 6062		IsMethod: true,
 6063	}
 6064
 6065	ctx = graphql.WithFieldContext(ctx, fc)
 6066	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6067		ctx = rctx // use context from middleware stack in children
 6068		return ec.resolvers.Label().Color(rctx, obj)
 6069	})
 6070	if err != nil {
 6071		ec.Error(ctx, err)
 6072		return graphql.Null
 6073	}
 6074	if resTmp == nil {
 6075		if !graphql.HasFieldError(ctx, fc) {
 6076			ec.Errorf(ctx, "must not be null")
 6077		}
 6078		return graphql.Null
 6079	}
 6080	res := resTmp.(*color.RGBA)
 6081	fc.Result = res
 6082	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6083}
 6084
 6085func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6086	defer func() {
 6087		if r := recover(); r != nil {
 6088			ec.Error(ctx, ec.Recover(ctx, r))
 6089			ret = graphql.Null
 6090		}
 6091	}()
 6092	fc := &graphql.FieldContext{
 6093		Object:   "LabelChangeOperation",
 6094		Field:    field,
 6095		Args:     nil,
 6096		IsMethod: true,
 6097	}
 6098
 6099	ctx = graphql.WithFieldContext(ctx, fc)
 6100	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6101		ctx = rctx // use context from middleware stack in children
 6102		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6103	})
 6104	if err != nil {
 6105		ec.Error(ctx, err)
 6106		return graphql.Null
 6107	}
 6108	if resTmp == nil {
 6109		if !graphql.HasFieldError(ctx, fc) {
 6110			ec.Errorf(ctx, "must not be null")
 6111		}
 6112		return graphql.Null
 6113	}
 6114	res := resTmp.(string)
 6115	fc.Result = res
 6116	return ec.marshalNString2string(ctx, field.Selections, res)
 6117}
 6118
 6119func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6120	defer func() {
 6121		if r := recover(); r != nil {
 6122			ec.Error(ctx, ec.Recover(ctx, r))
 6123			ret = graphql.Null
 6124		}
 6125	}()
 6126	fc := &graphql.FieldContext{
 6127		Object:   "LabelChangeOperation",
 6128		Field:    field,
 6129		Args:     nil,
 6130		IsMethod: true,
 6131	}
 6132
 6133	ctx = graphql.WithFieldContext(ctx, fc)
 6134	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6135		ctx = rctx // use context from middleware stack in children
 6136		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
 6137	})
 6138	if err != nil {
 6139		ec.Error(ctx, err)
 6140		return graphql.Null
 6141	}
 6142	if resTmp == nil {
 6143		if !graphql.HasFieldError(ctx, fc) {
 6144			ec.Errorf(ctx, "must not be null")
 6145		}
 6146		return graphql.Null
 6147	}
 6148	res := resTmp.(models.IdentityWrapper)
 6149	fc.Result = res
 6150	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6151}
 6152
 6153func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6154	defer func() {
 6155		if r := recover(); r != nil {
 6156			ec.Error(ctx, ec.Recover(ctx, r))
 6157			ret = graphql.Null
 6158		}
 6159	}()
 6160	fc := &graphql.FieldContext{
 6161		Object:   "LabelChangeOperation",
 6162		Field:    field,
 6163		Args:     nil,
 6164		IsMethod: true,
 6165	}
 6166
 6167	ctx = graphql.WithFieldContext(ctx, fc)
 6168	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6169		ctx = rctx // use context from middleware stack in children
 6170		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6171	})
 6172	if err != nil {
 6173		ec.Error(ctx, err)
 6174		return graphql.Null
 6175	}
 6176	if resTmp == nil {
 6177		if !graphql.HasFieldError(ctx, fc) {
 6178			ec.Errorf(ctx, "must not be null")
 6179		}
 6180		return graphql.Null
 6181	}
 6182	res := resTmp.(*time.Time)
 6183	fc.Result = res
 6184	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6185}
 6186
 6187func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6188	defer func() {
 6189		if r := recover(); r != nil {
 6190			ec.Error(ctx, ec.Recover(ctx, r))
 6191			ret = graphql.Null
 6192		}
 6193	}()
 6194	fc := &graphql.FieldContext{
 6195		Object:   "LabelChangeOperation",
 6196		Field:    field,
 6197		Args:     nil,
 6198		IsMethod: false,
 6199	}
 6200
 6201	ctx = graphql.WithFieldContext(ctx, fc)
 6202	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6203		ctx = rctx // use context from middleware stack in children
 6204		return obj.Added, nil
 6205	})
 6206	if err != nil {
 6207		ec.Error(ctx, err)
 6208		return graphql.Null
 6209	}
 6210	if resTmp == nil {
 6211		if !graphql.HasFieldError(ctx, fc) {
 6212			ec.Errorf(ctx, "must not be null")
 6213		}
 6214		return graphql.Null
 6215	}
 6216	res := resTmp.([]bug.Label)
 6217	fc.Result = res
 6218	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6219}
 6220
 6221func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6222	defer func() {
 6223		if r := recover(); r != nil {
 6224			ec.Error(ctx, ec.Recover(ctx, r))
 6225			ret = graphql.Null
 6226		}
 6227	}()
 6228	fc := &graphql.FieldContext{
 6229		Object:   "LabelChangeOperation",
 6230		Field:    field,
 6231		Args:     nil,
 6232		IsMethod: false,
 6233	}
 6234
 6235	ctx = graphql.WithFieldContext(ctx, fc)
 6236	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6237		ctx = rctx // use context from middleware stack in children
 6238		return obj.Removed, nil
 6239	})
 6240	if err != nil {
 6241		ec.Error(ctx, err)
 6242		return graphql.Null
 6243	}
 6244	if resTmp == nil {
 6245		if !graphql.HasFieldError(ctx, fc) {
 6246			ec.Errorf(ctx, "must not be null")
 6247		}
 6248		return graphql.Null
 6249	}
 6250	res := resTmp.([]bug.Label)
 6251	fc.Result = res
 6252	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6253}
 6254
 6255func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6256	defer func() {
 6257		if r := recover(); r != nil {
 6258			ec.Error(ctx, ec.Recover(ctx, r))
 6259			ret = graphql.Null
 6260		}
 6261	}()
 6262	fc := &graphql.FieldContext{
 6263		Object:   "LabelChangeResult",
 6264		Field:    field,
 6265		Args:     nil,
 6266		IsMethod: false,
 6267	}
 6268
 6269	ctx = graphql.WithFieldContext(ctx, fc)
 6270	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6271		ctx = rctx // use context from middleware stack in children
 6272		return obj.Label, nil
 6273	})
 6274	if err != nil {
 6275		ec.Error(ctx, err)
 6276		return graphql.Null
 6277	}
 6278	if resTmp == nil {
 6279		if !graphql.HasFieldError(ctx, fc) {
 6280			ec.Errorf(ctx, "must not be null")
 6281		}
 6282		return graphql.Null
 6283	}
 6284	res := resTmp.(bug.Label)
 6285	fc.Result = res
 6286	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6287}
 6288
 6289func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6290	defer func() {
 6291		if r := recover(); r != nil {
 6292			ec.Error(ctx, ec.Recover(ctx, r))
 6293			ret = graphql.Null
 6294		}
 6295	}()
 6296	fc := &graphql.FieldContext{
 6297		Object:   "LabelChangeResult",
 6298		Field:    field,
 6299		Args:     nil,
 6300		IsMethod: true,
 6301	}
 6302
 6303	ctx = graphql.WithFieldContext(ctx, fc)
 6304	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6305		ctx = rctx // use context from middleware stack in children
 6306		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6307	})
 6308	if err != nil {
 6309		ec.Error(ctx, err)
 6310		return graphql.Null
 6311	}
 6312	if resTmp == nil {
 6313		if !graphql.HasFieldError(ctx, fc) {
 6314			ec.Errorf(ctx, "must not be null")
 6315		}
 6316		return graphql.Null
 6317	}
 6318	res := resTmp.(models.LabelChangeStatus)
 6319	fc.Result = res
 6320	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6321}
 6322
 6323func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6324	defer func() {
 6325		if r := recover(); r != nil {
 6326			ec.Error(ctx, ec.Recover(ctx, r))
 6327			ret = graphql.Null
 6328		}
 6329	}()
 6330	fc := &graphql.FieldContext{
 6331		Object:   "LabelChangeTimelineItem",
 6332		Field:    field,
 6333		Args:     nil,
 6334		IsMethod: true,
 6335	}
 6336
 6337	ctx = graphql.WithFieldContext(ctx, fc)
 6338	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6339		ctx = rctx // use context from middleware stack in children
 6340		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6341	})
 6342	if err != nil {
 6343		ec.Error(ctx, err)
 6344		return graphql.Null
 6345	}
 6346	if resTmp == nil {
 6347		if !graphql.HasFieldError(ctx, fc) {
 6348			ec.Errorf(ctx, "must not be null")
 6349		}
 6350		return graphql.Null
 6351	}
 6352	res := resTmp.(string)
 6353	fc.Result = res
 6354	return ec.marshalNString2string(ctx, field.Selections, res)
 6355}
 6356
 6357func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6358	defer func() {
 6359		if r := recover(); r != nil {
 6360			ec.Error(ctx, ec.Recover(ctx, r))
 6361			ret = graphql.Null
 6362		}
 6363	}()
 6364	fc := &graphql.FieldContext{
 6365		Object:   "LabelChangeTimelineItem",
 6366		Field:    field,
 6367		Args:     nil,
 6368		IsMethod: true,
 6369	}
 6370
 6371	ctx = graphql.WithFieldContext(ctx, fc)
 6372	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6373		ctx = rctx // use context from middleware stack in children
 6374		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
 6375	})
 6376	if err != nil {
 6377		ec.Error(ctx, err)
 6378		return graphql.Null
 6379	}
 6380	if resTmp == nil {
 6381		if !graphql.HasFieldError(ctx, fc) {
 6382			ec.Errorf(ctx, "must not be null")
 6383		}
 6384		return graphql.Null
 6385	}
 6386	res := resTmp.(models.IdentityWrapper)
 6387	fc.Result = res
 6388	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6389}
 6390
 6391func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6392	defer func() {
 6393		if r := recover(); r != nil {
 6394			ec.Error(ctx, ec.Recover(ctx, r))
 6395			ret = graphql.Null
 6396		}
 6397	}()
 6398	fc := &graphql.FieldContext{
 6399		Object:   "LabelChangeTimelineItem",
 6400		Field:    field,
 6401		Args:     nil,
 6402		IsMethod: true,
 6403	}
 6404
 6405	ctx = graphql.WithFieldContext(ctx, fc)
 6406	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6407		ctx = rctx // use context from middleware stack in children
 6408		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6409	})
 6410	if err != nil {
 6411		ec.Error(ctx, err)
 6412		return graphql.Null
 6413	}
 6414	if resTmp == nil {
 6415		if !graphql.HasFieldError(ctx, fc) {
 6416			ec.Errorf(ctx, "must not be null")
 6417		}
 6418		return graphql.Null
 6419	}
 6420	res := resTmp.(*time.Time)
 6421	fc.Result = res
 6422	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6423}
 6424
 6425func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6426	defer func() {
 6427		if r := recover(); r != nil {
 6428			ec.Error(ctx, ec.Recover(ctx, r))
 6429			ret = graphql.Null
 6430		}
 6431	}()
 6432	fc := &graphql.FieldContext{
 6433		Object:   "LabelChangeTimelineItem",
 6434		Field:    field,
 6435		Args:     nil,
 6436		IsMethod: false,
 6437	}
 6438
 6439	ctx = graphql.WithFieldContext(ctx, fc)
 6440	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6441		ctx = rctx // use context from middleware stack in children
 6442		return obj.Added, nil
 6443	})
 6444	if err != nil {
 6445		ec.Error(ctx, err)
 6446		return graphql.Null
 6447	}
 6448	if resTmp == nil {
 6449		if !graphql.HasFieldError(ctx, fc) {
 6450			ec.Errorf(ctx, "must not be null")
 6451		}
 6452		return graphql.Null
 6453	}
 6454	res := resTmp.([]bug.Label)
 6455	fc.Result = res
 6456	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6457}
 6458
 6459func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6460	defer func() {
 6461		if r := recover(); r != nil {
 6462			ec.Error(ctx, ec.Recover(ctx, r))
 6463			ret = graphql.Null
 6464		}
 6465	}()
 6466	fc := &graphql.FieldContext{
 6467		Object:   "LabelChangeTimelineItem",
 6468		Field:    field,
 6469		Args:     nil,
 6470		IsMethod: false,
 6471	}
 6472
 6473	ctx = graphql.WithFieldContext(ctx, fc)
 6474	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6475		ctx = rctx // use context from middleware stack in children
 6476		return obj.Removed, nil
 6477	})
 6478	if err != nil {
 6479		ec.Error(ctx, err)
 6480		return graphql.Null
 6481	}
 6482	if resTmp == nil {
 6483		if !graphql.HasFieldError(ctx, fc) {
 6484			ec.Errorf(ctx, "must not be null")
 6485		}
 6486		return graphql.Null
 6487	}
 6488	res := resTmp.([]bug.Label)
 6489	fc.Result = res
 6490	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6491}
 6492
 6493func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6494	defer func() {
 6495		if r := recover(); r != nil {
 6496			ec.Error(ctx, ec.Recover(ctx, r))
 6497			ret = graphql.Null
 6498		}
 6499	}()
 6500	fc := &graphql.FieldContext{
 6501		Object:   "LabelConnection",
 6502		Field:    field,
 6503		Args:     nil,
 6504		IsMethod: false,
 6505	}
 6506
 6507	ctx = graphql.WithFieldContext(ctx, fc)
 6508	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6509		ctx = rctx // use context from middleware stack in children
 6510		return obj.Edges, nil
 6511	})
 6512	if err != nil {
 6513		ec.Error(ctx, err)
 6514		return graphql.Null
 6515	}
 6516	if resTmp == nil {
 6517		if !graphql.HasFieldError(ctx, fc) {
 6518			ec.Errorf(ctx, "must not be null")
 6519		}
 6520		return graphql.Null
 6521	}
 6522	res := resTmp.([]*models.LabelEdge)
 6523	fc.Result = res
 6524	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 6525}
 6526
 6527func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6528	defer func() {
 6529		if r := recover(); r != nil {
 6530			ec.Error(ctx, ec.Recover(ctx, r))
 6531			ret = graphql.Null
 6532		}
 6533	}()
 6534	fc := &graphql.FieldContext{
 6535		Object:   "LabelConnection",
 6536		Field:    field,
 6537		Args:     nil,
 6538		IsMethod: false,
 6539	}
 6540
 6541	ctx = graphql.WithFieldContext(ctx, fc)
 6542	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6543		ctx = rctx // use context from middleware stack in children
 6544		return obj.Nodes, nil
 6545	})
 6546	if err != nil {
 6547		ec.Error(ctx, err)
 6548		return graphql.Null
 6549	}
 6550	if resTmp == nil {
 6551		if !graphql.HasFieldError(ctx, fc) {
 6552			ec.Errorf(ctx, "must not be null")
 6553		}
 6554		return graphql.Null
 6555	}
 6556	res := resTmp.([]bug.Label)
 6557	fc.Result = res
 6558	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6559}
 6560
 6561func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6562	defer func() {
 6563		if r := recover(); r != nil {
 6564			ec.Error(ctx, ec.Recover(ctx, r))
 6565			ret = graphql.Null
 6566		}
 6567	}()
 6568	fc := &graphql.FieldContext{
 6569		Object:   "LabelConnection",
 6570		Field:    field,
 6571		Args:     nil,
 6572		IsMethod: false,
 6573	}
 6574
 6575	ctx = graphql.WithFieldContext(ctx, fc)
 6576	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6577		ctx = rctx // use context from middleware stack in children
 6578		return obj.PageInfo, nil
 6579	})
 6580	if err != nil {
 6581		ec.Error(ctx, err)
 6582		return graphql.Null
 6583	}
 6584	if resTmp == nil {
 6585		if !graphql.HasFieldError(ctx, fc) {
 6586			ec.Errorf(ctx, "must not be null")
 6587		}
 6588		return graphql.Null
 6589	}
 6590	res := resTmp.(*models.PageInfo)
 6591	fc.Result = res
 6592	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6593}
 6594
 6595func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6596	defer func() {
 6597		if r := recover(); r != nil {
 6598			ec.Error(ctx, ec.Recover(ctx, r))
 6599			ret = graphql.Null
 6600		}
 6601	}()
 6602	fc := &graphql.FieldContext{
 6603		Object:   "LabelConnection",
 6604		Field:    field,
 6605		Args:     nil,
 6606		IsMethod: false,
 6607	}
 6608
 6609	ctx = graphql.WithFieldContext(ctx, fc)
 6610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6611		ctx = rctx // use context from middleware stack in children
 6612		return obj.TotalCount, nil
 6613	})
 6614	if err != nil {
 6615		ec.Error(ctx, err)
 6616		return graphql.Null
 6617	}
 6618	if resTmp == nil {
 6619		if !graphql.HasFieldError(ctx, fc) {
 6620			ec.Errorf(ctx, "must not be null")
 6621		}
 6622		return graphql.Null
 6623	}
 6624	res := resTmp.(int)
 6625	fc.Result = res
 6626	return ec.marshalNInt2int(ctx, field.Selections, res)
 6627}
 6628
 6629func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6630	defer func() {
 6631		if r := recover(); r != nil {
 6632			ec.Error(ctx, ec.Recover(ctx, r))
 6633			ret = graphql.Null
 6634		}
 6635	}()
 6636	fc := &graphql.FieldContext{
 6637		Object:   "LabelEdge",
 6638		Field:    field,
 6639		Args:     nil,
 6640		IsMethod: false,
 6641	}
 6642
 6643	ctx = graphql.WithFieldContext(ctx, fc)
 6644	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6645		ctx = rctx // use context from middleware stack in children
 6646		return obj.Cursor, nil
 6647	})
 6648	if err != nil {
 6649		ec.Error(ctx, err)
 6650		return graphql.Null
 6651	}
 6652	if resTmp == nil {
 6653		if !graphql.HasFieldError(ctx, fc) {
 6654			ec.Errorf(ctx, "must not be null")
 6655		}
 6656		return graphql.Null
 6657	}
 6658	res := resTmp.(string)
 6659	fc.Result = res
 6660	return ec.marshalNString2string(ctx, field.Selections, res)
 6661}
 6662
 6663func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6664	defer func() {
 6665		if r := recover(); r != nil {
 6666			ec.Error(ctx, ec.Recover(ctx, r))
 6667			ret = graphql.Null
 6668		}
 6669	}()
 6670	fc := &graphql.FieldContext{
 6671		Object:   "LabelEdge",
 6672		Field:    field,
 6673		Args:     nil,
 6674		IsMethod: false,
 6675	}
 6676
 6677	ctx = graphql.WithFieldContext(ctx, fc)
 6678	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6679		ctx = rctx // use context from middleware stack in children
 6680		return obj.Node, nil
 6681	})
 6682	if err != nil {
 6683		ec.Error(ctx, err)
 6684		return graphql.Null
 6685	}
 6686	if resTmp == nil {
 6687		if !graphql.HasFieldError(ctx, fc) {
 6688			ec.Errorf(ctx, "must not be null")
 6689		}
 6690		return graphql.Null
 6691	}
 6692	res := resTmp.(bug.Label)
 6693	fc.Result = res
 6694	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6695}
 6696
 6697func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6698	defer func() {
 6699		if r := recover(); r != nil {
 6700			ec.Error(ctx, ec.Recover(ctx, r))
 6701			ret = graphql.Null
 6702		}
 6703	}()
 6704	fc := &graphql.FieldContext{
 6705		Object:   "Mutation",
 6706		Field:    field,
 6707		Args:     nil,
 6708		IsMethod: true,
 6709	}
 6710
 6711	ctx = graphql.WithFieldContext(ctx, fc)
 6712	rawArgs := field.ArgumentMap(ec.Variables)
 6713	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6714	if err != nil {
 6715		ec.Error(ctx, err)
 6716		return graphql.Null
 6717	}
 6718	fc.Args = args
 6719	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6720		ctx = rctx // use context from middleware stack in children
 6721		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 6722	})
 6723	if err != nil {
 6724		ec.Error(ctx, err)
 6725		return graphql.Null
 6726	}
 6727	if resTmp == nil {
 6728		if !graphql.HasFieldError(ctx, fc) {
 6729			ec.Errorf(ctx, "must not be null")
 6730		}
 6731		return graphql.Null
 6732	}
 6733	res := resTmp.(*models.NewBugPayload)
 6734	fc.Result = res
 6735	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 6736}
 6737
 6738func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6739	defer func() {
 6740		if r := recover(); r != nil {
 6741			ec.Error(ctx, ec.Recover(ctx, r))
 6742			ret = graphql.Null
 6743		}
 6744	}()
 6745	fc := &graphql.FieldContext{
 6746		Object:   "Mutation",
 6747		Field:    field,
 6748		Args:     nil,
 6749		IsMethod: true,
 6750	}
 6751
 6752	ctx = graphql.WithFieldContext(ctx, fc)
 6753	rawArgs := field.ArgumentMap(ec.Variables)
 6754	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 6755	if err != nil {
 6756		ec.Error(ctx, err)
 6757		return graphql.Null
 6758	}
 6759	fc.Args = args
 6760	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6761		ctx = rctx // use context from middleware stack in children
 6762		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 6763	})
 6764	if err != nil {
 6765		ec.Error(ctx, err)
 6766		return graphql.Null
 6767	}
 6768	if resTmp == nil {
 6769		if !graphql.HasFieldError(ctx, fc) {
 6770			ec.Errorf(ctx, "must not be null")
 6771		}
 6772		return graphql.Null
 6773	}
 6774	res := resTmp.(*models.AddCommentPayload)
 6775	fc.Result = res
 6776	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 6777}
 6778
 6779func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6780	defer func() {
 6781		if r := recover(); r != nil {
 6782			ec.Error(ctx, ec.Recover(ctx, r))
 6783			ret = graphql.Null
 6784		}
 6785	}()
 6786	fc := &graphql.FieldContext{
 6787		Object:   "Mutation",
 6788		Field:    field,
 6789		Args:     nil,
 6790		IsMethod: true,
 6791	}
 6792
 6793	ctx = graphql.WithFieldContext(ctx, fc)
 6794	rawArgs := field.ArgumentMap(ec.Variables)
 6795	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 6796	if err != nil {
 6797		ec.Error(ctx, err)
 6798		return graphql.Null
 6799	}
 6800	fc.Args = args
 6801	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6802		ctx = rctx // use context from middleware stack in children
 6803		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 6804	})
 6805	if err != nil {
 6806		ec.Error(ctx, err)
 6807		return graphql.Null
 6808	}
 6809	if resTmp == nil {
 6810		if !graphql.HasFieldError(ctx, fc) {
 6811			ec.Errorf(ctx, "must not be null")
 6812		}
 6813		return graphql.Null
 6814	}
 6815	res := resTmp.(*models.ChangeLabelPayload)
 6816	fc.Result = res
 6817	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 6818}
 6819
 6820func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6821	defer func() {
 6822		if r := recover(); r != nil {
 6823			ec.Error(ctx, ec.Recover(ctx, r))
 6824			ret = graphql.Null
 6825		}
 6826	}()
 6827	fc := &graphql.FieldContext{
 6828		Object:   "Mutation",
 6829		Field:    field,
 6830		Args:     nil,
 6831		IsMethod: true,
 6832	}
 6833
 6834	ctx = graphql.WithFieldContext(ctx, fc)
 6835	rawArgs := field.ArgumentMap(ec.Variables)
 6836	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 6837	if err != nil {
 6838		ec.Error(ctx, err)
 6839		return graphql.Null
 6840	}
 6841	fc.Args = args
 6842	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6843		ctx = rctx // use context from middleware stack in children
 6844		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 6845	})
 6846	if err != nil {
 6847		ec.Error(ctx, err)
 6848		return graphql.Null
 6849	}
 6850	if resTmp == nil {
 6851		if !graphql.HasFieldError(ctx, fc) {
 6852			ec.Errorf(ctx, "must not be null")
 6853		}
 6854		return graphql.Null
 6855	}
 6856	res := resTmp.(*models.OpenBugPayload)
 6857	fc.Result = res
 6858	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 6859}
 6860
 6861func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6862	defer func() {
 6863		if r := recover(); r != nil {
 6864			ec.Error(ctx, ec.Recover(ctx, r))
 6865			ret = graphql.Null
 6866		}
 6867	}()
 6868	fc := &graphql.FieldContext{
 6869		Object:   "Mutation",
 6870		Field:    field,
 6871		Args:     nil,
 6872		IsMethod: true,
 6873	}
 6874
 6875	ctx = graphql.WithFieldContext(ctx, fc)
 6876	rawArgs := field.ArgumentMap(ec.Variables)
 6877	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 6878	if err != nil {
 6879		ec.Error(ctx, err)
 6880		return graphql.Null
 6881	}
 6882	fc.Args = args
 6883	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6884		ctx = rctx // use context from middleware stack in children
 6885		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 6886	})
 6887	if err != nil {
 6888		ec.Error(ctx, err)
 6889		return graphql.Null
 6890	}
 6891	if resTmp == nil {
 6892		if !graphql.HasFieldError(ctx, fc) {
 6893			ec.Errorf(ctx, "must not be null")
 6894		}
 6895		return graphql.Null
 6896	}
 6897	res := resTmp.(*models.CloseBugPayload)
 6898	fc.Result = res
 6899	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 6900}
 6901
 6902func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6903	defer func() {
 6904		if r := recover(); r != nil {
 6905			ec.Error(ctx, ec.Recover(ctx, r))
 6906			ret = graphql.Null
 6907		}
 6908	}()
 6909	fc := &graphql.FieldContext{
 6910		Object:   "Mutation",
 6911		Field:    field,
 6912		Args:     nil,
 6913		IsMethod: true,
 6914	}
 6915
 6916	ctx = graphql.WithFieldContext(ctx, fc)
 6917	rawArgs := field.ArgumentMap(ec.Variables)
 6918	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 6919	if err != nil {
 6920		ec.Error(ctx, err)
 6921		return graphql.Null
 6922	}
 6923	fc.Args = args
 6924	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6925		ctx = rctx // use context from middleware stack in children
 6926		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 6927	})
 6928	if err != nil {
 6929		ec.Error(ctx, err)
 6930		return graphql.Null
 6931	}
 6932	if resTmp == nil {
 6933		if !graphql.HasFieldError(ctx, fc) {
 6934			ec.Errorf(ctx, "must not be null")
 6935		}
 6936		return graphql.Null
 6937	}
 6938	res := resTmp.(*models.SetTitlePayload)
 6939	fc.Result = res
 6940	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 6941}
 6942
 6943func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 6944	defer func() {
 6945		if r := recover(); r != nil {
 6946			ec.Error(ctx, ec.Recover(ctx, r))
 6947			ret = graphql.Null
 6948		}
 6949	}()
 6950	fc := &graphql.FieldContext{
 6951		Object:   "NewBugPayload",
 6952		Field:    field,
 6953		Args:     nil,
 6954		IsMethod: false,
 6955	}
 6956
 6957	ctx = graphql.WithFieldContext(ctx, fc)
 6958	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6959		ctx = rctx // use context from middleware stack in children
 6960		return obj.ClientMutationID, nil
 6961	})
 6962	if err != nil {
 6963		ec.Error(ctx, err)
 6964		return graphql.Null
 6965	}
 6966	if resTmp == nil {
 6967		return graphql.Null
 6968	}
 6969	res := resTmp.(*string)
 6970	fc.Result = res
 6971	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6972}
 6973
 6974func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 6975	defer func() {
 6976		if r := recover(); r != nil {
 6977			ec.Error(ctx, ec.Recover(ctx, r))
 6978			ret = graphql.Null
 6979		}
 6980	}()
 6981	fc := &graphql.FieldContext{
 6982		Object:   "NewBugPayload",
 6983		Field:    field,
 6984		Args:     nil,
 6985		IsMethod: false,
 6986	}
 6987
 6988	ctx = graphql.WithFieldContext(ctx, fc)
 6989	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6990		ctx = rctx // use context from middleware stack in children
 6991		return obj.Bug, nil
 6992	})
 6993	if err != nil {
 6994		ec.Error(ctx, err)
 6995		return graphql.Null
 6996	}
 6997	if resTmp == nil {
 6998		if !graphql.HasFieldError(ctx, fc) {
 6999			ec.Errorf(ctx, "must not be null")
 7000		}
 7001		return graphql.Null
 7002	}
 7003	res := resTmp.(models.BugWrapper)
 7004	fc.Result = res
 7005	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7006}
 7007
 7008func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7009	defer func() {
 7010		if r := recover(); r != nil {
 7011			ec.Error(ctx, ec.Recover(ctx, r))
 7012			ret = graphql.Null
 7013		}
 7014	}()
 7015	fc := &graphql.FieldContext{
 7016		Object:   "NewBugPayload",
 7017		Field:    field,
 7018		Args:     nil,
 7019		IsMethod: false,
 7020	}
 7021
 7022	ctx = graphql.WithFieldContext(ctx, fc)
 7023	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7024		ctx = rctx // use context from middleware stack in children
 7025		return obj.Operation, nil
 7026	})
 7027	if err != nil {
 7028		ec.Error(ctx, err)
 7029		return graphql.Null
 7030	}
 7031	if resTmp == nil {
 7032		if !graphql.HasFieldError(ctx, fc) {
 7033			ec.Errorf(ctx, "must not be null")
 7034		}
 7035		return graphql.Null
 7036	}
 7037	res := resTmp.(*bug.CreateOperation)
 7038	fc.Result = res
 7039	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7040}
 7041
 7042func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7043	defer func() {
 7044		if r := recover(); r != nil {
 7045			ec.Error(ctx, ec.Recover(ctx, r))
 7046			ret = graphql.Null
 7047		}
 7048	}()
 7049	fc := &graphql.FieldContext{
 7050		Object:   "OpenBugPayload",
 7051		Field:    field,
 7052		Args:     nil,
 7053		IsMethod: false,
 7054	}
 7055
 7056	ctx = graphql.WithFieldContext(ctx, fc)
 7057	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7058		ctx = rctx // use context from middleware stack in children
 7059		return obj.ClientMutationID, nil
 7060	})
 7061	if err != nil {
 7062		ec.Error(ctx, err)
 7063		return graphql.Null
 7064	}
 7065	if resTmp == nil {
 7066		return graphql.Null
 7067	}
 7068	res := resTmp.(*string)
 7069	fc.Result = res
 7070	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7071}
 7072
 7073func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7074	defer func() {
 7075		if r := recover(); r != nil {
 7076			ec.Error(ctx, ec.Recover(ctx, r))
 7077			ret = graphql.Null
 7078		}
 7079	}()
 7080	fc := &graphql.FieldContext{
 7081		Object:   "OpenBugPayload",
 7082		Field:    field,
 7083		Args:     nil,
 7084		IsMethod: false,
 7085	}
 7086
 7087	ctx = graphql.WithFieldContext(ctx, fc)
 7088	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7089		ctx = rctx // use context from middleware stack in children
 7090		return obj.Bug, nil
 7091	})
 7092	if err != nil {
 7093		ec.Error(ctx, err)
 7094		return graphql.Null
 7095	}
 7096	if resTmp == nil {
 7097		if !graphql.HasFieldError(ctx, fc) {
 7098			ec.Errorf(ctx, "must not be null")
 7099		}
 7100		return graphql.Null
 7101	}
 7102	res := resTmp.(models.BugWrapper)
 7103	fc.Result = res
 7104	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7105}
 7106
 7107func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7108	defer func() {
 7109		if r := recover(); r != nil {
 7110			ec.Error(ctx, ec.Recover(ctx, r))
 7111			ret = graphql.Null
 7112		}
 7113	}()
 7114	fc := &graphql.FieldContext{
 7115		Object:   "OpenBugPayload",
 7116		Field:    field,
 7117		Args:     nil,
 7118		IsMethod: false,
 7119	}
 7120
 7121	ctx = graphql.WithFieldContext(ctx, fc)
 7122	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7123		ctx = rctx // use context from middleware stack in children
 7124		return obj.Operation, nil
 7125	})
 7126	if err != nil {
 7127		ec.Error(ctx, err)
 7128		return graphql.Null
 7129	}
 7130	if resTmp == nil {
 7131		if !graphql.HasFieldError(ctx, fc) {
 7132			ec.Errorf(ctx, "must not be null")
 7133		}
 7134		return graphql.Null
 7135	}
 7136	res := resTmp.(*bug.SetStatusOperation)
 7137	fc.Result = res
 7138	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7139}
 7140
 7141func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7142	defer func() {
 7143		if r := recover(); r != nil {
 7144			ec.Error(ctx, ec.Recover(ctx, r))
 7145			ret = graphql.Null
 7146		}
 7147	}()
 7148	fc := &graphql.FieldContext{
 7149		Object:   "OperationConnection",
 7150		Field:    field,
 7151		Args:     nil,
 7152		IsMethod: false,
 7153	}
 7154
 7155	ctx = graphql.WithFieldContext(ctx, fc)
 7156	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7157		ctx = rctx // use context from middleware stack in children
 7158		return obj.Edges, nil
 7159	})
 7160	if err != nil {
 7161		ec.Error(ctx, err)
 7162		return graphql.Null
 7163	}
 7164	if resTmp == nil {
 7165		if !graphql.HasFieldError(ctx, fc) {
 7166			ec.Errorf(ctx, "must not be null")
 7167		}
 7168		return graphql.Null
 7169	}
 7170	res := resTmp.([]*models.OperationEdge)
 7171	fc.Result = res
 7172	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7173}
 7174
 7175func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7176	defer func() {
 7177		if r := recover(); r != nil {
 7178			ec.Error(ctx, ec.Recover(ctx, r))
 7179			ret = graphql.Null
 7180		}
 7181	}()
 7182	fc := &graphql.FieldContext{
 7183		Object:   "OperationConnection",
 7184		Field:    field,
 7185		Args:     nil,
 7186		IsMethod: false,
 7187	}
 7188
 7189	ctx = graphql.WithFieldContext(ctx, fc)
 7190	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7191		ctx = rctx // use context from middleware stack in children
 7192		return obj.Nodes, nil
 7193	})
 7194	if err != nil {
 7195		ec.Error(ctx, err)
 7196		return graphql.Null
 7197	}
 7198	if resTmp == nil {
 7199		if !graphql.HasFieldError(ctx, fc) {
 7200			ec.Errorf(ctx, "must not be null")
 7201		}
 7202		return graphql.Null
 7203	}
 7204	res := resTmp.([]bug.Operation)
 7205	fc.Result = res
 7206	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7207}
 7208
 7209func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7210	defer func() {
 7211		if r := recover(); r != nil {
 7212			ec.Error(ctx, ec.Recover(ctx, r))
 7213			ret = graphql.Null
 7214		}
 7215	}()
 7216	fc := &graphql.FieldContext{
 7217		Object:   "OperationConnection",
 7218		Field:    field,
 7219		Args:     nil,
 7220		IsMethod: false,
 7221	}
 7222
 7223	ctx = graphql.WithFieldContext(ctx, fc)
 7224	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7225		ctx = rctx // use context from middleware stack in children
 7226		return obj.PageInfo, nil
 7227	})
 7228	if err != nil {
 7229		ec.Error(ctx, err)
 7230		return graphql.Null
 7231	}
 7232	if resTmp == nil {
 7233		if !graphql.HasFieldError(ctx, fc) {
 7234			ec.Errorf(ctx, "must not be null")
 7235		}
 7236		return graphql.Null
 7237	}
 7238	res := resTmp.(*models.PageInfo)
 7239	fc.Result = res
 7240	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7241}
 7242
 7243func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7244	defer func() {
 7245		if r := recover(); r != nil {
 7246			ec.Error(ctx, ec.Recover(ctx, r))
 7247			ret = graphql.Null
 7248		}
 7249	}()
 7250	fc := &graphql.FieldContext{
 7251		Object:   "OperationConnection",
 7252		Field:    field,
 7253		Args:     nil,
 7254		IsMethod: false,
 7255	}
 7256
 7257	ctx = graphql.WithFieldContext(ctx, fc)
 7258	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7259		ctx = rctx // use context from middleware stack in children
 7260		return obj.TotalCount, nil
 7261	})
 7262	if err != nil {
 7263		ec.Error(ctx, err)
 7264		return graphql.Null
 7265	}
 7266	if resTmp == nil {
 7267		if !graphql.HasFieldError(ctx, fc) {
 7268			ec.Errorf(ctx, "must not be null")
 7269		}
 7270		return graphql.Null
 7271	}
 7272	res := resTmp.(int)
 7273	fc.Result = res
 7274	return ec.marshalNInt2int(ctx, field.Selections, res)
 7275}
 7276
 7277func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7278	defer func() {
 7279		if r := recover(); r != nil {
 7280			ec.Error(ctx, ec.Recover(ctx, r))
 7281			ret = graphql.Null
 7282		}
 7283	}()
 7284	fc := &graphql.FieldContext{
 7285		Object:   "OperationEdge",
 7286		Field:    field,
 7287		Args:     nil,
 7288		IsMethod: false,
 7289	}
 7290
 7291	ctx = graphql.WithFieldContext(ctx, fc)
 7292	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7293		ctx = rctx // use context from middleware stack in children
 7294		return obj.Cursor, nil
 7295	})
 7296	if err != nil {
 7297		ec.Error(ctx, err)
 7298		return graphql.Null
 7299	}
 7300	if resTmp == nil {
 7301		if !graphql.HasFieldError(ctx, fc) {
 7302			ec.Errorf(ctx, "must not be null")
 7303		}
 7304		return graphql.Null
 7305	}
 7306	res := resTmp.(string)
 7307	fc.Result = res
 7308	return ec.marshalNString2string(ctx, field.Selections, res)
 7309}
 7310
 7311func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7312	defer func() {
 7313		if r := recover(); r != nil {
 7314			ec.Error(ctx, ec.Recover(ctx, r))
 7315			ret = graphql.Null
 7316		}
 7317	}()
 7318	fc := &graphql.FieldContext{
 7319		Object:   "OperationEdge",
 7320		Field:    field,
 7321		Args:     nil,
 7322		IsMethod: false,
 7323	}
 7324
 7325	ctx = graphql.WithFieldContext(ctx, fc)
 7326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7327		ctx = rctx // use context from middleware stack in children
 7328		return obj.Node, nil
 7329	})
 7330	if err != nil {
 7331		ec.Error(ctx, err)
 7332		return graphql.Null
 7333	}
 7334	if resTmp == nil {
 7335		if !graphql.HasFieldError(ctx, fc) {
 7336			ec.Errorf(ctx, "must not be null")
 7337		}
 7338		return graphql.Null
 7339	}
 7340	res := resTmp.(bug.Operation)
 7341	fc.Result = res
 7342	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7343}
 7344
 7345func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7346	defer func() {
 7347		if r := recover(); r != nil {
 7348			ec.Error(ctx, ec.Recover(ctx, r))
 7349			ret = graphql.Null
 7350		}
 7351	}()
 7352	fc := &graphql.FieldContext{
 7353		Object:   "PageInfo",
 7354		Field:    field,
 7355		Args:     nil,
 7356		IsMethod: false,
 7357	}
 7358
 7359	ctx = graphql.WithFieldContext(ctx, fc)
 7360	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7361		ctx = rctx // use context from middleware stack in children
 7362		return obj.HasNextPage, nil
 7363	})
 7364	if err != nil {
 7365		ec.Error(ctx, err)
 7366		return graphql.Null
 7367	}
 7368	if resTmp == nil {
 7369		if !graphql.HasFieldError(ctx, fc) {
 7370			ec.Errorf(ctx, "must not be null")
 7371		}
 7372		return graphql.Null
 7373	}
 7374	res := resTmp.(bool)
 7375	fc.Result = res
 7376	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7377}
 7378
 7379func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7380	defer func() {
 7381		if r := recover(); r != nil {
 7382			ec.Error(ctx, ec.Recover(ctx, r))
 7383			ret = graphql.Null
 7384		}
 7385	}()
 7386	fc := &graphql.FieldContext{
 7387		Object:   "PageInfo",
 7388		Field:    field,
 7389		Args:     nil,
 7390		IsMethod: false,
 7391	}
 7392
 7393	ctx = graphql.WithFieldContext(ctx, fc)
 7394	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7395		ctx = rctx // use context from middleware stack in children
 7396		return obj.HasPreviousPage, nil
 7397	})
 7398	if err != nil {
 7399		ec.Error(ctx, err)
 7400		return graphql.Null
 7401	}
 7402	if resTmp == nil {
 7403		if !graphql.HasFieldError(ctx, fc) {
 7404			ec.Errorf(ctx, "must not be null")
 7405		}
 7406		return graphql.Null
 7407	}
 7408	res := resTmp.(bool)
 7409	fc.Result = res
 7410	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7411}
 7412
 7413func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7414	defer func() {
 7415		if r := recover(); r != nil {
 7416			ec.Error(ctx, ec.Recover(ctx, r))
 7417			ret = graphql.Null
 7418		}
 7419	}()
 7420	fc := &graphql.FieldContext{
 7421		Object:   "PageInfo",
 7422		Field:    field,
 7423		Args:     nil,
 7424		IsMethod: false,
 7425	}
 7426
 7427	ctx = graphql.WithFieldContext(ctx, fc)
 7428	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7429		ctx = rctx // use context from middleware stack in children
 7430		return obj.StartCursor, nil
 7431	})
 7432	if err != nil {
 7433		ec.Error(ctx, err)
 7434		return graphql.Null
 7435	}
 7436	if resTmp == nil {
 7437		if !graphql.HasFieldError(ctx, fc) {
 7438			ec.Errorf(ctx, "must not be null")
 7439		}
 7440		return graphql.Null
 7441	}
 7442	res := resTmp.(string)
 7443	fc.Result = res
 7444	return ec.marshalNString2string(ctx, field.Selections, res)
 7445}
 7446
 7447func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7448	defer func() {
 7449		if r := recover(); r != nil {
 7450			ec.Error(ctx, ec.Recover(ctx, r))
 7451			ret = graphql.Null
 7452		}
 7453	}()
 7454	fc := &graphql.FieldContext{
 7455		Object:   "PageInfo",
 7456		Field:    field,
 7457		Args:     nil,
 7458		IsMethod: false,
 7459	}
 7460
 7461	ctx = graphql.WithFieldContext(ctx, fc)
 7462	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7463		ctx = rctx // use context from middleware stack in children
 7464		return obj.EndCursor, nil
 7465	})
 7466	if err != nil {
 7467		ec.Error(ctx, err)
 7468		return graphql.Null
 7469	}
 7470	if resTmp == nil {
 7471		if !graphql.HasFieldError(ctx, fc) {
 7472			ec.Errorf(ctx, "must not be null")
 7473		}
 7474		return graphql.Null
 7475	}
 7476	res := resTmp.(string)
 7477	fc.Result = res
 7478	return ec.marshalNString2string(ctx, field.Selections, res)
 7479}
 7480
 7481func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7482	defer func() {
 7483		if r := recover(); r != nil {
 7484			ec.Error(ctx, ec.Recover(ctx, r))
 7485			ret = graphql.Null
 7486		}
 7487	}()
 7488	fc := &graphql.FieldContext{
 7489		Object:   "Query",
 7490		Field:    field,
 7491		Args:     nil,
 7492		IsMethod: true,
 7493	}
 7494
 7495	ctx = graphql.WithFieldContext(ctx, fc)
 7496	rawArgs := field.ArgumentMap(ec.Variables)
 7497	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7498	if err != nil {
 7499		ec.Error(ctx, err)
 7500		return graphql.Null
 7501	}
 7502	fc.Args = args
 7503	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7504		ctx = rctx // use context from middleware stack in children
 7505		return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
 7506	})
 7507	if err != nil {
 7508		ec.Error(ctx, err)
 7509		return graphql.Null
 7510	}
 7511	if resTmp == nil {
 7512		return graphql.Null
 7513	}
 7514	res := resTmp.(*models.Repository)
 7515	fc.Result = res
 7516	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7517}
 7518
 7519func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7520	defer func() {
 7521		if r := recover(); r != nil {
 7522			ec.Error(ctx, ec.Recover(ctx, r))
 7523			ret = graphql.Null
 7524		}
 7525	}()
 7526	fc := &graphql.FieldContext{
 7527		Object:   "Query",
 7528		Field:    field,
 7529		Args:     nil,
 7530		IsMethod: true,
 7531	}
 7532
 7533	ctx = graphql.WithFieldContext(ctx, fc)
 7534	rawArgs := field.ArgumentMap(ec.Variables)
 7535	args, err := ec.field_Query___type_args(ctx, rawArgs)
 7536	if err != nil {
 7537		ec.Error(ctx, err)
 7538		return graphql.Null
 7539	}
 7540	fc.Args = args
 7541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7542		ctx = rctx // use context from middleware stack in children
 7543		return ec.introspectType(args["name"].(string))
 7544	})
 7545	if err != nil {
 7546		ec.Error(ctx, err)
 7547		return graphql.Null
 7548	}
 7549	if resTmp == nil {
 7550		return graphql.Null
 7551	}
 7552	res := resTmp.(*introspection.Type)
 7553	fc.Result = res
 7554	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7555}
 7556
 7557func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7558	defer func() {
 7559		if r := recover(); r != nil {
 7560			ec.Error(ctx, ec.Recover(ctx, r))
 7561			ret = graphql.Null
 7562		}
 7563	}()
 7564	fc := &graphql.FieldContext{
 7565		Object:   "Query",
 7566		Field:    field,
 7567		Args:     nil,
 7568		IsMethod: true,
 7569	}
 7570
 7571	ctx = graphql.WithFieldContext(ctx, fc)
 7572	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7573		ctx = rctx // use context from middleware stack in children
 7574		return ec.introspectSchema()
 7575	})
 7576	if err != nil {
 7577		ec.Error(ctx, err)
 7578		return graphql.Null
 7579	}
 7580	if resTmp == nil {
 7581		return graphql.Null
 7582	}
 7583	res := resTmp.(*introspection.Schema)
 7584	fc.Result = res
 7585	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 7586}
 7587
 7588func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7589	defer func() {
 7590		if r := recover(); r != nil {
 7591			ec.Error(ctx, ec.Recover(ctx, r))
 7592			ret = graphql.Null
 7593		}
 7594	}()
 7595	fc := &graphql.FieldContext{
 7596		Object:   "Repository",
 7597		Field:    field,
 7598		Args:     nil,
 7599		IsMethod: true,
 7600	}
 7601
 7602	ctx = graphql.WithFieldContext(ctx, fc)
 7603	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7604		ctx = rctx // use context from middleware stack in children
 7605		return ec.resolvers.Repository().Name(rctx, obj)
 7606	})
 7607	if err != nil {
 7608		ec.Error(ctx, err)
 7609		return graphql.Null
 7610	}
 7611	if resTmp == nil {
 7612		return graphql.Null
 7613	}
 7614	res := resTmp.(*string)
 7615	fc.Result = res
 7616	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7617}
 7618
 7619func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7620	defer func() {
 7621		if r := recover(); r != nil {
 7622			ec.Error(ctx, ec.Recover(ctx, r))
 7623			ret = graphql.Null
 7624		}
 7625	}()
 7626	fc := &graphql.FieldContext{
 7627		Object:   "Repository",
 7628		Field:    field,
 7629		Args:     nil,
 7630		IsMethod: true,
 7631	}
 7632
 7633	ctx = graphql.WithFieldContext(ctx, fc)
 7634	rawArgs := field.ArgumentMap(ec.Variables)
 7635	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 7636	if err != nil {
 7637		ec.Error(ctx, err)
 7638		return graphql.Null
 7639	}
 7640	fc.Args = args
 7641	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7642		ctx = rctx // use context from middleware stack in children
 7643		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 7644	})
 7645	if err != nil {
 7646		ec.Error(ctx, err)
 7647		return graphql.Null
 7648	}
 7649	if resTmp == nil {
 7650		if !graphql.HasFieldError(ctx, fc) {
 7651			ec.Errorf(ctx, "must not be null")
 7652		}
 7653		return graphql.Null
 7654	}
 7655	res := resTmp.(*models.BugConnection)
 7656	fc.Result = res
 7657	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 7658}
 7659
 7660func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7661	defer func() {
 7662		if r := recover(); r != nil {
 7663			ec.Error(ctx, ec.Recover(ctx, r))
 7664			ret = graphql.Null
 7665		}
 7666	}()
 7667	fc := &graphql.FieldContext{
 7668		Object:   "Repository",
 7669		Field:    field,
 7670		Args:     nil,
 7671		IsMethod: true,
 7672	}
 7673
 7674	ctx = graphql.WithFieldContext(ctx, fc)
 7675	rawArgs := field.ArgumentMap(ec.Variables)
 7676	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 7677	if err != nil {
 7678		ec.Error(ctx, err)
 7679		return graphql.Null
 7680	}
 7681	fc.Args = args
 7682	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7683		ctx = rctx // use context from middleware stack in children
 7684		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 7685	})
 7686	if err != nil {
 7687		ec.Error(ctx, err)
 7688		return graphql.Null
 7689	}
 7690	if resTmp == nil {
 7691		return graphql.Null
 7692	}
 7693	res := resTmp.(models.BugWrapper)
 7694	fc.Result = res
 7695	return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7696}
 7697
 7698func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7699	defer func() {
 7700		if r := recover(); r != nil {
 7701			ec.Error(ctx, ec.Recover(ctx, r))
 7702			ret = graphql.Null
 7703		}
 7704	}()
 7705	fc := &graphql.FieldContext{
 7706		Object:   "Repository",
 7707		Field:    field,
 7708		Args:     nil,
 7709		IsMethod: true,
 7710	}
 7711
 7712	ctx = graphql.WithFieldContext(ctx, fc)
 7713	rawArgs := field.ArgumentMap(ec.Variables)
 7714	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 7715	if err != nil {
 7716		ec.Error(ctx, err)
 7717		return graphql.Null
 7718	}
 7719	fc.Args = args
 7720	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7721		ctx = rctx // use context from middleware stack in children
 7722		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7723	})
 7724	if err != nil {
 7725		ec.Error(ctx, err)
 7726		return graphql.Null
 7727	}
 7728	if resTmp == nil {
 7729		if !graphql.HasFieldError(ctx, fc) {
 7730			ec.Errorf(ctx, "must not be null")
 7731		}
 7732		return graphql.Null
 7733	}
 7734	res := resTmp.(*models.IdentityConnection)
 7735	fc.Result = res
 7736	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 7737}
 7738
 7739func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7740	defer func() {
 7741		if r := recover(); r != nil {
 7742			ec.Error(ctx, ec.Recover(ctx, r))
 7743			ret = graphql.Null
 7744		}
 7745	}()
 7746	fc := &graphql.FieldContext{
 7747		Object:   "Repository",
 7748		Field:    field,
 7749		Args:     nil,
 7750		IsMethod: true,
 7751	}
 7752
 7753	ctx = graphql.WithFieldContext(ctx, fc)
 7754	rawArgs := field.ArgumentMap(ec.Variables)
 7755	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 7756	if err != nil {
 7757		ec.Error(ctx, err)
 7758		return graphql.Null
 7759	}
 7760	fc.Args = args
 7761	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7762		ctx = rctx // use context from middleware stack in children
 7763		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 7764	})
 7765	if err != nil {
 7766		ec.Error(ctx, err)
 7767		return graphql.Null
 7768	}
 7769	if resTmp == nil {
 7770		return graphql.Null
 7771	}
 7772	res := resTmp.(models.IdentityWrapper)
 7773	fc.Result = res
 7774	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7775}
 7776
 7777func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7778	defer func() {
 7779		if r := recover(); r != nil {
 7780			ec.Error(ctx, ec.Recover(ctx, r))
 7781			ret = graphql.Null
 7782		}
 7783	}()
 7784	fc := &graphql.FieldContext{
 7785		Object:   "Repository",
 7786		Field:    field,
 7787		Args:     nil,
 7788		IsMethod: true,
 7789	}
 7790
 7791	ctx = graphql.WithFieldContext(ctx, fc)
 7792	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7793		ctx = rctx // use context from middleware stack in children
 7794		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 7795	})
 7796	if err != nil {
 7797		ec.Error(ctx, err)
 7798		return graphql.Null
 7799	}
 7800	if resTmp == nil {
 7801		return graphql.Null
 7802	}
 7803	res := resTmp.(models.IdentityWrapper)
 7804	fc.Result = res
 7805	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7806}
 7807
 7808func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7809	defer func() {
 7810		if r := recover(); r != nil {
 7811			ec.Error(ctx, ec.Recover(ctx, r))
 7812			ret = graphql.Null
 7813		}
 7814	}()
 7815	fc := &graphql.FieldContext{
 7816		Object:   "Repository",
 7817		Field:    field,
 7818		Args:     nil,
 7819		IsMethod: true,
 7820	}
 7821
 7822	ctx = graphql.WithFieldContext(ctx, fc)
 7823	rawArgs := field.ArgumentMap(ec.Variables)
 7824	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 7825	if err != nil {
 7826		ec.Error(ctx, err)
 7827		return graphql.Null
 7828	}
 7829	fc.Args = args
 7830	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7831		ctx = rctx // use context from middleware stack in children
 7832		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7833	})
 7834	if err != nil {
 7835		ec.Error(ctx, err)
 7836		return graphql.Null
 7837	}
 7838	if resTmp == nil {
 7839		if !graphql.HasFieldError(ctx, fc) {
 7840			ec.Errorf(ctx, "must not be null")
 7841		}
 7842		return graphql.Null
 7843	}
 7844	res := resTmp.(*models.LabelConnection)
 7845	fc.Result = res
 7846	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 7847}
 7848
 7849func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7850	defer func() {
 7851		if r := recover(); r != nil {
 7852			ec.Error(ctx, ec.Recover(ctx, r))
 7853			ret = graphql.Null
 7854		}
 7855	}()
 7856	fc := &graphql.FieldContext{
 7857		Object:   "SetStatusOperation",
 7858		Field:    field,
 7859		Args:     nil,
 7860		IsMethod: true,
 7861	}
 7862
 7863	ctx = graphql.WithFieldContext(ctx, fc)
 7864	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7865		ctx = rctx // use context from middleware stack in children
 7866		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 7867	})
 7868	if err != nil {
 7869		ec.Error(ctx, err)
 7870		return graphql.Null
 7871	}
 7872	if resTmp == nil {
 7873		if !graphql.HasFieldError(ctx, fc) {
 7874			ec.Errorf(ctx, "must not be null")
 7875		}
 7876		return graphql.Null
 7877	}
 7878	res := resTmp.(string)
 7879	fc.Result = res
 7880	return ec.marshalNString2string(ctx, field.Selections, res)
 7881}
 7882
 7883func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7884	defer func() {
 7885		if r := recover(); r != nil {
 7886			ec.Error(ctx, ec.Recover(ctx, r))
 7887			ret = graphql.Null
 7888		}
 7889	}()
 7890	fc := &graphql.FieldContext{
 7891		Object:   "SetStatusOperation",
 7892		Field:    field,
 7893		Args:     nil,
 7894		IsMethod: true,
 7895	}
 7896
 7897	ctx = graphql.WithFieldContext(ctx, fc)
 7898	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7899		ctx = rctx // use context from middleware stack in children
 7900		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
 7901	})
 7902	if err != nil {
 7903		ec.Error(ctx, err)
 7904		return graphql.Null
 7905	}
 7906	if resTmp == nil {
 7907		if !graphql.HasFieldError(ctx, fc) {
 7908			ec.Errorf(ctx, "must not be null")
 7909		}
 7910		return graphql.Null
 7911	}
 7912	res := resTmp.(models.IdentityWrapper)
 7913	fc.Result = res
 7914	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 7915}
 7916
 7917func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7918	defer func() {
 7919		if r := recover(); r != nil {
 7920			ec.Error(ctx, ec.Recover(ctx, r))
 7921			ret = graphql.Null
 7922		}
 7923	}()
 7924	fc := &graphql.FieldContext{
 7925		Object:   "SetStatusOperation",
 7926		Field:    field,
 7927		Args:     nil,
 7928		IsMethod: true,
 7929	}
 7930
 7931	ctx = graphql.WithFieldContext(ctx, fc)
 7932	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7933		ctx = rctx // use context from middleware stack in children
 7934		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 7935	})
 7936	if err != nil {
 7937		ec.Error(ctx, err)
 7938		return graphql.Null
 7939	}
 7940	if resTmp == nil {
 7941		if !graphql.HasFieldError(ctx, fc) {
 7942			ec.Errorf(ctx, "must not be null")
 7943		}
 7944		return graphql.Null
 7945	}
 7946	res := resTmp.(*time.Time)
 7947	fc.Result = res
 7948	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7949}
 7950
 7951func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 7952	defer func() {
 7953		if r := recover(); r != nil {
 7954			ec.Error(ctx, ec.Recover(ctx, r))
 7955			ret = graphql.Null
 7956		}
 7957	}()
 7958	fc := &graphql.FieldContext{
 7959		Object:   "SetStatusOperation",
 7960		Field:    field,
 7961		Args:     nil,
 7962		IsMethod: true,
 7963	}
 7964
 7965	ctx = graphql.WithFieldContext(ctx, fc)
 7966	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7967		ctx = rctx // use context from middleware stack in children
 7968		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 7969	})
 7970	if err != nil {
 7971		ec.Error(ctx, err)
 7972		return graphql.Null
 7973	}
 7974	if resTmp == nil {
 7975		if !graphql.HasFieldError(ctx, fc) {
 7976			ec.Errorf(ctx, "must not be null")
 7977		}
 7978		return graphql.Null
 7979	}
 7980	res := resTmp.(models.Status)
 7981	fc.Result = res
 7982	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 7983}
 7984
 7985func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 7986	defer func() {
 7987		if r := recover(); r != nil {
 7988			ec.Error(ctx, ec.Recover(ctx, r))
 7989			ret = graphql.Null
 7990		}
 7991	}()
 7992	fc := &graphql.FieldContext{
 7993		Object:   "SetStatusTimelineItem",
 7994		Field:    field,
 7995		Args:     nil,
 7996		IsMethod: true,
 7997	}
 7998
 7999	ctx = graphql.WithFieldContext(ctx, fc)
 8000	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8001		ctx = rctx // use context from middleware stack in children
 8002		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8003	})
 8004	if err != nil {
 8005		ec.Error(ctx, err)
 8006		return graphql.Null
 8007	}
 8008	if resTmp == nil {
 8009		if !graphql.HasFieldError(ctx, fc) {
 8010			ec.Errorf(ctx, "must not be null")
 8011		}
 8012		return graphql.Null
 8013	}
 8014	res := resTmp.(string)
 8015	fc.Result = res
 8016	return ec.marshalNString2string(ctx, field.Selections, res)
 8017}
 8018
 8019func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8020	defer func() {
 8021		if r := recover(); r != nil {
 8022			ec.Error(ctx, ec.Recover(ctx, r))
 8023			ret = graphql.Null
 8024		}
 8025	}()
 8026	fc := &graphql.FieldContext{
 8027		Object:   "SetStatusTimelineItem",
 8028		Field:    field,
 8029		Args:     nil,
 8030		IsMethod: true,
 8031	}
 8032
 8033	ctx = graphql.WithFieldContext(ctx, fc)
 8034	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8035		ctx = rctx // use context from middleware stack in children
 8036		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
 8037	})
 8038	if err != nil {
 8039		ec.Error(ctx, err)
 8040		return graphql.Null
 8041	}
 8042	if resTmp == nil {
 8043		if !graphql.HasFieldError(ctx, fc) {
 8044			ec.Errorf(ctx, "must not be null")
 8045		}
 8046		return graphql.Null
 8047	}
 8048	res := resTmp.(models.IdentityWrapper)
 8049	fc.Result = res
 8050	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8051}
 8052
 8053func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8054	defer func() {
 8055		if r := recover(); r != nil {
 8056			ec.Error(ctx, ec.Recover(ctx, r))
 8057			ret = graphql.Null
 8058		}
 8059	}()
 8060	fc := &graphql.FieldContext{
 8061		Object:   "SetStatusTimelineItem",
 8062		Field:    field,
 8063		Args:     nil,
 8064		IsMethod: true,
 8065	}
 8066
 8067	ctx = graphql.WithFieldContext(ctx, fc)
 8068	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8069		ctx = rctx // use context from middleware stack in children
 8070		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8071	})
 8072	if err != nil {
 8073		ec.Error(ctx, err)
 8074		return graphql.Null
 8075	}
 8076	if resTmp == nil {
 8077		if !graphql.HasFieldError(ctx, fc) {
 8078			ec.Errorf(ctx, "must not be null")
 8079		}
 8080		return graphql.Null
 8081	}
 8082	res := resTmp.(*time.Time)
 8083	fc.Result = res
 8084	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8085}
 8086
 8087func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8088	defer func() {
 8089		if r := recover(); r != nil {
 8090			ec.Error(ctx, ec.Recover(ctx, r))
 8091			ret = graphql.Null
 8092		}
 8093	}()
 8094	fc := &graphql.FieldContext{
 8095		Object:   "SetStatusTimelineItem",
 8096		Field:    field,
 8097		Args:     nil,
 8098		IsMethod: true,
 8099	}
 8100
 8101	ctx = graphql.WithFieldContext(ctx, fc)
 8102	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8103		ctx = rctx // use context from middleware stack in children
 8104		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8105	})
 8106	if err != nil {
 8107		ec.Error(ctx, err)
 8108		return graphql.Null
 8109	}
 8110	if resTmp == nil {
 8111		if !graphql.HasFieldError(ctx, fc) {
 8112			ec.Errorf(ctx, "must not be null")
 8113		}
 8114		return graphql.Null
 8115	}
 8116	res := resTmp.(models.Status)
 8117	fc.Result = res
 8118	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8119}
 8120
 8121func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8122	defer func() {
 8123		if r := recover(); r != nil {
 8124			ec.Error(ctx, ec.Recover(ctx, r))
 8125			ret = graphql.Null
 8126		}
 8127	}()
 8128	fc := &graphql.FieldContext{
 8129		Object:   "SetTitleOperation",
 8130		Field:    field,
 8131		Args:     nil,
 8132		IsMethod: true,
 8133	}
 8134
 8135	ctx = graphql.WithFieldContext(ctx, fc)
 8136	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8137		ctx = rctx // use context from middleware stack in children
 8138		return ec.resolvers.SetTitleOperation().ID(rctx, obj)
 8139	})
 8140	if err != nil {
 8141		ec.Error(ctx, err)
 8142		return graphql.Null
 8143	}
 8144	if resTmp == nil {
 8145		if !graphql.HasFieldError(ctx, fc) {
 8146			ec.Errorf(ctx, "must not be null")
 8147		}
 8148		return graphql.Null
 8149	}
 8150	res := resTmp.(string)
 8151	fc.Result = res
 8152	return ec.marshalNString2string(ctx, field.Selections, res)
 8153}
 8154
 8155func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8156	defer func() {
 8157		if r := recover(); r != nil {
 8158			ec.Error(ctx, ec.Recover(ctx, r))
 8159			ret = graphql.Null
 8160		}
 8161	}()
 8162	fc := &graphql.FieldContext{
 8163		Object:   "SetTitleOperation",
 8164		Field:    field,
 8165		Args:     nil,
 8166		IsMethod: true,
 8167	}
 8168
 8169	ctx = graphql.WithFieldContext(ctx, fc)
 8170	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8171		ctx = rctx // use context from middleware stack in children
 8172		return ec.resolvers.SetTitleOperation().Author(rctx, obj)
 8173	})
 8174	if err != nil {
 8175		ec.Error(ctx, err)
 8176		return graphql.Null
 8177	}
 8178	if resTmp == nil {
 8179		if !graphql.HasFieldError(ctx, fc) {
 8180			ec.Errorf(ctx, "must not be null")
 8181		}
 8182		return graphql.Null
 8183	}
 8184	res := resTmp.(models.IdentityWrapper)
 8185	fc.Result = res
 8186	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8187}
 8188
 8189func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8190	defer func() {
 8191		if r := recover(); r != nil {
 8192			ec.Error(ctx, ec.Recover(ctx, r))
 8193			ret = graphql.Null
 8194		}
 8195	}()
 8196	fc := &graphql.FieldContext{
 8197		Object:   "SetTitleOperation",
 8198		Field:    field,
 8199		Args:     nil,
 8200		IsMethod: true,
 8201	}
 8202
 8203	ctx = graphql.WithFieldContext(ctx, fc)
 8204	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8205		ctx = rctx // use context from middleware stack in children
 8206		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8207	})
 8208	if err != nil {
 8209		ec.Error(ctx, err)
 8210		return graphql.Null
 8211	}
 8212	if resTmp == nil {
 8213		if !graphql.HasFieldError(ctx, fc) {
 8214			ec.Errorf(ctx, "must not be null")
 8215		}
 8216		return graphql.Null
 8217	}
 8218	res := resTmp.(*time.Time)
 8219	fc.Result = res
 8220	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8221}
 8222
 8223func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8224	defer func() {
 8225		if r := recover(); r != nil {
 8226			ec.Error(ctx, ec.Recover(ctx, r))
 8227			ret = graphql.Null
 8228		}
 8229	}()
 8230	fc := &graphql.FieldContext{
 8231		Object:   "SetTitleOperation",
 8232		Field:    field,
 8233		Args:     nil,
 8234		IsMethod: false,
 8235	}
 8236
 8237	ctx = graphql.WithFieldContext(ctx, fc)
 8238	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8239		ctx = rctx // use context from middleware stack in children
 8240		return obj.Title, nil
 8241	})
 8242	if err != nil {
 8243		ec.Error(ctx, err)
 8244		return graphql.Null
 8245	}
 8246	if resTmp == nil {
 8247		if !graphql.HasFieldError(ctx, fc) {
 8248			ec.Errorf(ctx, "must not be null")
 8249		}
 8250		return graphql.Null
 8251	}
 8252	res := resTmp.(string)
 8253	fc.Result = res
 8254	return ec.marshalNString2string(ctx, field.Selections, res)
 8255}
 8256
 8257func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8258	defer func() {
 8259		if r := recover(); r != nil {
 8260			ec.Error(ctx, ec.Recover(ctx, r))
 8261			ret = graphql.Null
 8262		}
 8263	}()
 8264	fc := &graphql.FieldContext{
 8265		Object:   "SetTitleOperation",
 8266		Field:    field,
 8267		Args:     nil,
 8268		IsMethod: false,
 8269	}
 8270
 8271	ctx = graphql.WithFieldContext(ctx, fc)
 8272	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8273		ctx = rctx // use context from middleware stack in children
 8274		return obj.Was, nil
 8275	})
 8276	if err != nil {
 8277		ec.Error(ctx, err)
 8278		return graphql.Null
 8279	}
 8280	if resTmp == nil {
 8281		if !graphql.HasFieldError(ctx, fc) {
 8282			ec.Errorf(ctx, "must not be null")
 8283		}
 8284		return graphql.Null
 8285	}
 8286	res := resTmp.(string)
 8287	fc.Result = res
 8288	return ec.marshalNString2string(ctx, field.Selections, res)
 8289}
 8290
 8291func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8292	defer func() {
 8293		if r := recover(); r != nil {
 8294			ec.Error(ctx, ec.Recover(ctx, r))
 8295			ret = graphql.Null
 8296		}
 8297	}()
 8298	fc := &graphql.FieldContext{
 8299		Object:   "SetTitlePayload",
 8300		Field:    field,
 8301		Args:     nil,
 8302		IsMethod: false,
 8303	}
 8304
 8305	ctx = graphql.WithFieldContext(ctx, fc)
 8306	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8307		ctx = rctx // use context from middleware stack in children
 8308		return obj.ClientMutationID, nil
 8309	})
 8310	if err != nil {
 8311		ec.Error(ctx, err)
 8312		return graphql.Null
 8313	}
 8314	if resTmp == nil {
 8315		return graphql.Null
 8316	}
 8317	res := resTmp.(*string)
 8318	fc.Result = res
 8319	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8320}
 8321
 8322func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8323	defer func() {
 8324		if r := recover(); r != nil {
 8325			ec.Error(ctx, ec.Recover(ctx, r))
 8326			ret = graphql.Null
 8327		}
 8328	}()
 8329	fc := &graphql.FieldContext{
 8330		Object:   "SetTitlePayload",
 8331		Field:    field,
 8332		Args:     nil,
 8333		IsMethod: false,
 8334	}
 8335
 8336	ctx = graphql.WithFieldContext(ctx, fc)
 8337	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8338		ctx = rctx // use context from middleware stack in children
 8339		return obj.Bug, nil
 8340	})
 8341	if err != nil {
 8342		ec.Error(ctx, err)
 8343		return graphql.Null
 8344	}
 8345	if resTmp == nil {
 8346		if !graphql.HasFieldError(ctx, fc) {
 8347			ec.Errorf(ctx, "must not be null")
 8348		}
 8349		return graphql.Null
 8350	}
 8351	res := resTmp.(models.BugWrapper)
 8352	fc.Result = res
 8353	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 8354}
 8355
 8356func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8357	defer func() {
 8358		if r := recover(); r != nil {
 8359			ec.Error(ctx, ec.Recover(ctx, r))
 8360			ret = graphql.Null
 8361		}
 8362	}()
 8363	fc := &graphql.FieldContext{
 8364		Object:   "SetTitlePayload",
 8365		Field:    field,
 8366		Args:     nil,
 8367		IsMethod: false,
 8368	}
 8369
 8370	ctx = graphql.WithFieldContext(ctx, fc)
 8371	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8372		ctx = rctx // use context from middleware stack in children
 8373		return obj.Operation, nil
 8374	})
 8375	if err != nil {
 8376		ec.Error(ctx, err)
 8377		return graphql.Null
 8378	}
 8379	if resTmp == nil {
 8380		if !graphql.HasFieldError(ctx, fc) {
 8381			ec.Errorf(ctx, "must not be null")
 8382		}
 8383		return graphql.Null
 8384	}
 8385	res := resTmp.(*bug.SetTitleOperation)
 8386	fc.Result = res
 8387	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8388}
 8389
 8390func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8391	defer func() {
 8392		if r := recover(); r != nil {
 8393			ec.Error(ctx, ec.Recover(ctx, r))
 8394			ret = graphql.Null
 8395		}
 8396	}()
 8397	fc := &graphql.FieldContext{
 8398		Object:   "SetTitleTimelineItem",
 8399		Field:    field,
 8400		Args:     nil,
 8401		IsMethod: true,
 8402	}
 8403
 8404	ctx = graphql.WithFieldContext(ctx, fc)
 8405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8406		ctx = rctx // use context from middleware stack in children
 8407		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8408	})
 8409	if err != nil {
 8410		ec.Error(ctx, err)
 8411		return graphql.Null
 8412	}
 8413	if resTmp == nil {
 8414		if !graphql.HasFieldError(ctx, fc) {
 8415			ec.Errorf(ctx, "must not be null")
 8416		}
 8417		return graphql.Null
 8418	}
 8419	res := resTmp.(string)
 8420	fc.Result = res
 8421	return ec.marshalNString2string(ctx, field.Selections, res)
 8422}
 8423
 8424func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8425	defer func() {
 8426		if r := recover(); r != nil {
 8427			ec.Error(ctx, ec.Recover(ctx, r))
 8428			ret = graphql.Null
 8429		}
 8430	}()
 8431	fc := &graphql.FieldContext{
 8432		Object:   "SetTitleTimelineItem",
 8433		Field:    field,
 8434		Args:     nil,
 8435		IsMethod: true,
 8436	}
 8437
 8438	ctx = graphql.WithFieldContext(ctx, fc)
 8439	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8440		ctx = rctx // use context from middleware stack in children
 8441		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
 8442	})
 8443	if err != nil {
 8444		ec.Error(ctx, err)
 8445		return graphql.Null
 8446	}
 8447	if resTmp == nil {
 8448		if !graphql.HasFieldError(ctx, fc) {
 8449			ec.Errorf(ctx, "must not be null")
 8450		}
 8451		return graphql.Null
 8452	}
 8453	res := resTmp.(models.IdentityWrapper)
 8454	fc.Result = res
 8455	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8456}
 8457
 8458func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8459	defer func() {
 8460		if r := recover(); r != nil {
 8461			ec.Error(ctx, ec.Recover(ctx, r))
 8462			ret = graphql.Null
 8463		}
 8464	}()
 8465	fc := &graphql.FieldContext{
 8466		Object:   "SetTitleTimelineItem",
 8467		Field:    field,
 8468		Args:     nil,
 8469		IsMethod: true,
 8470	}
 8471
 8472	ctx = graphql.WithFieldContext(ctx, fc)
 8473	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8474		ctx = rctx // use context from middleware stack in children
 8475		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8476	})
 8477	if err != nil {
 8478		ec.Error(ctx, err)
 8479		return graphql.Null
 8480	}
 8481	if resTmp == nil {
 8482		if !graphql.HasFieldError(ctx, fc) {
 8483			ec.Errorf(ctx, "must not be null")
 8484		}
 8485		return graphql.Null
 8486	}
 8487	res := resTmp.(*time.Time)
 8488	fc.Result = res
 8489	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8490}
 8491
 8492func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8493	defer func() {
 8494		if r := recover(); r != nil {
 8495			ec.Error(ctx, ec.Recover(ctx, r))
 8496			ret = graphql.Null
 8497		}
 8498	}()
 8499	fc := &graphql.FieldContext{
 8500		Object:   "SetTitleTimelineItem",
 8501		Field:    field,
 8502		Args:     nil,
 8503		IsMethod: false,
 8504	}
 8505
 8506	ctx = graphql.WithFieldContext(ctx, fc)
 8507	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8508		ctx = rctx // use context from middleware stack in children
 8509		return obj.Title, nil
 8510	})
 8511	if err != nil {
 8512		ec.Error(ctx, err)
 8513		return graphql.Null
 8514	}
 8515	if resTmp == nil {
 8516		if !graphql.HasFieldError(ctx, fc) {
 8517			ec.Errorf(ctx, "must not be null")
 8518		}
 8519		return graphql.Null
 8520	}
 8521	res := resTmp.(string)
 8522	fc.Result = res
 8523	return ec.marshalNString2string(ctx, field.Selections, res)
 8524}
 8525
 8526func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8527	defer func() {
 8528		if r := recover(); r != nil {
 8529			ec.Error(ctx, ec.Recover(ctx, r))
 8530			ret = graphql.Null
 8531		}
 8532	}()
 8533	fc := &graphql.FieldContext{
 8534		Object:   "SetTitleTimelineItem",
 8535		Field:    field,
 8536		Args:     nil,
 8537		IsMethod: false,
 8538	}
 8539
 8540	ctx = graphql.WithFieldContext(ctx, fc)
 8541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8542		ctx = rctx // use context from middleware stack in children
 8543		return obj.Was, nil
 8544	})
 8545	if err != nil {
 8546		ec.Error(ctx, err)
 8547		return graphql.Null
 8548	}
 8549	if resTmp == nil {
 8550		if !graphql.HasFieldError(ctx, fc) {
 8551			ec.Errorf(ctx, "must not be null")
 8552		}
 8553		return graphql.Null
 8554	}
 8555	res := resTmp.(string)
 8556	fc.Result = res
 8557	return ec.marshalNString2string(ctx, field.Selections, res)
 8558}
 8559
 8560func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8561	defer func() {
 8562		if r := recover(); r != nil {
 8563			ec.Error(ctx, ec.Recover(ctx, r))
 8564			ret = graphql.Null
 8565		}
 8566	}()
 8567	fc := &graphql.FieldContext{
 8568		Object:   "TimelineItemConnection",
 8569		Field:    field,
 8570		Args:     nil,
 8571		IsMethod: false,
 8572	}
 8573
 8574	ctx = graphql.WithFieldContext(ctx, fc)
 8575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8576		ctx = rctx // use context from middleware stack in children
 8577		return obj.Edges, nil
 8578	})
 8579	if err != nil {
 8580		ec.Error(ctx, err)
 8581		return graphql.Null
 8582	}
 8583	if resTmp == nil {
 8584		if !graphql.HasFieldError(ctx, fc) {
 8585			ec.Errorf(ctx, "must not be null")
 8586		}
 8587		return graphql.Null
 8588	}
 8589	res := resTmp.([]*models.TimelineItemEdge)
 8590	fc.Result = res
 8591	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 8592}
 8593
 8594func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8595	defer func() {
 8596		if r := recover(); r != nil {
 8597			ec.Error(ctx, ec.Recover(ctx, r))
 8598			ret = graphql.Null
 8599		}
 8600	}()
 8601	fc := &graphql.FieldContext{
 8602		Object:   "TimelineItemConnection",
 8603		Field:    field,
 8604		Args:     nil,
 8605		IsMethod: false,
 8606	}
 8607
 8608	ctx = graphql.WithFieldContext(ctx, fc)
 8609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8610		ctx = rctx // use context from middleware stack in children
 8611		return obj.Nodes, nil
 8612	})
 8613	if err != nil {
 8614		ec.Error(ctx, err)
 8615		return graphql.Null
 8616	}
 8617	if resTmp == nil {
 8618		if !graphql.HasFieldError(ctx, fc) {
 8619			ec.Errorf(ctx, "must not be null")
 8620		}
 8621		return graphql.Null
 8622	}
 8623	res := resTmp.([]bug.TimelineItem)
 8624	fc.Result = res
 8625	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 8626}
 8627
 8628func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8629	defer func() {
 8630		if r := recover(); r != nil {
 8631			ec.Error(ctx, ec.Recover(ctx, r))
 8632			ret = graphql.Null
 8633		}
 8634	}()
 8635	fc := &graphql.FieldContext{
 8636		Object:   "TimelineItemConnection",
 8637		Field:    field,
 8638		Args:     nil,
 8639		IsMethod: false,
 8640	}
 8641
 8642	ctx = graphql.WithFieldContext(ctx, fc)
 8643	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8644		ctx = rctx // use context from middleware stack in children
 8645		return obj.PageInfo, nil
 8646	})
 8647	if err != nil {
 8648		ec.Error(ctx, err)
 8649		return graphql.Null
 8650	}
 8651	if resTmp == nil {
 8652		if !graphql.HasFieldError(ctx, fc) {
 8653			ec.Errorf(ctx, "must not be null")
 8654		}
 8655		return graphql.Null
 8656	}
 8657	res := resTmp.(*models.PageInfo)
 8658	fc.Result = res
 8659	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 8660}
 8661
 8662func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8663	defer func() {
 8664		if r := recover(); r != nil {
 8665			ec.Error(ctx, ec.Recover(ctx, r))
 8666			ret = graphql.Null
 8667		}
 8668	}()
 8669	fc := &graphql.FieldContext{
 8670		Object:   "TimelineItemConnection",
 8671		Field:    field,
 8672		Args:     nil,
 8673		IsMethod: false,
 8674	}
 8675
 8676	ctx = graphql.WithFieldContext(ctx, fc)
 8677	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8678		ctx = rctx // use context from middleware stack in children
 8679		return obj.TotalCount, nil
 8680	})
 8681	if err != nil {
 8682		ec.Error(ctx, err)
 8683		return graphql.Null
 8684	}
 8685	if resTmp == nil {
 8686		if !graphql.HasFieldError(ctx, fc) {
 8687			ec.Errorf(ctx, "must not be null")
 8688		}
 8689		return graphql.Null
 8690	}
 8691	res := resTmp.(int)
 8692	fc.Result = res
 8693	return ec.marshalNInt2int(ctx, field.Selections, res)
 8694}
 8695
 8696func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8697	defer func() {
 8698		if r := recover(); r != nil {
 8699			ec.Error(ctx, ec.Recover(ctx, r))
 8700			ret = graphql.Null
 8701		}
 8702	}()
 8703	fc := &graphql.FieldContext{
 8704		Object:   "TimelineItemEdge",
 8705		Field:    field,
 8706		Args:     nil,
 8707		IsMethod: false,
 8708	}
 8709
 8710	ctx = graphql.WithFieldContext(ctx, fc)
 8711	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8712		ctx = rctx // use context from middleware stack in children
 8713		return obj.Cursor, nil
 8714	})
 8715	if err != nil {
 8716		ec.Error(ctx, err)
 8717		return graphql.Null
 8718	}
 8719	if resTmp == nil {
 8720		if !graphql.HasFieldError(ctx, fc) {
 8721			ec.Errorf(ctx, "must not be null")
 8722		}
 8723		return graphql.Null
 8724	}
 8725	res := resTmp.(string)
 8726	fc.Result = res
 8727	return ec.marshalNString2string(ctx, field.Selections, res)
 8728}
 8729
 8730func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8731	defer func() {
 8732		if r := recover(); r != nil {
 8733			ec.Error(ctx, ec.Recover(ctx, r))
 8734			ret = graphql.Null
 8735		}
 8736	}()
 8737	fc := &graphql.FieldContext{
 8738		Object:   "TimelineItemEdge",
 8739		Field:    field,
 8740		Args:     nil,
 8741		IsMethod: false,
 8742	}
 8743
 8744	ctx = graphql.WithFieldContext(ctx, fc)
 8745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8746		ctx = rctx // use context from middleware stack in children
 8747		return obj.Node, nil
 8748	})
 8749	if err != nil {
 8750		ec.Error(ctx, err)
 8751		return graphql.Null
 8752	}
 8753	if resTmp == nil {
 8754		if !graphql.HasFieldError(ctx, fc) {
 8755			ec.Errorf(ctx, "must not be null")
 8756		}
 8757		return graphql.Null
 8758	}
 8759	res := resTmp.(bug.TimelineItem)
 8760	fc.Result = res
 8761	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 8762}
 8763
 8764func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8765	defer func() {
 8766		if r := recover(); r != nil {
 8767			ec.Error(ctx, ec.Recover(ctx, r))
 8768			ret = graphql.Null
 8769		}
 8770	}()
 8771	fc := &graphql.FieldContext{
 8772		Object:   "__Directive",
 8773		Field:    field,
 8774		Args:     nil,
 8775		IsMethod: false,
 8776	}
 8777
 8778	ctx = graphql.WithFieldContext(ctx, fc)
 8779	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8780		ctx = rctx // use context from middleware stack in children
 8781		return obj.Name, nil
 8782	})
 8783	if err != nil {
 8784		ec.Error(ctx, err)
 8785		return graphql.Null
 8786	}
 8787	if resTmp == nil {
 8788		if !graphql.HasFieldError(ctx, fc) {
 8789			ec.Errorf(ctx, "must not be null")
 8790		}
 8791		return graphql.Null
 8792	}
 8793	res := resTmp.(string)
 8794	fc.Result = res
 8795	return ec.marshalNString2string(ctx, field.Selections, res)
 8796}
 8797
 8798func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8799	defer func() {
 8800		if r := recover(); r != nil {
 8801			ec.Error(ctx, ec.Recover(ctx, r))
 8802			ret = graphql.Null
 8803		}
 8804	}()
 8805	fc := &graphql.FieldContext{
 8806		Object:   "__Directive",
 8807		Field:    field,
 8808		Args:     nil,
 8809		IsMethod: false,
 8810	}
 8811
 8812	ctx = graphql.WithFieldContext(ctx, fc)
 8813	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8814		ctx = rctx // use context from middleware stack in children
 8815		return obj.Description, nil
 8816	})
 8817	if err != nil {
 8818		ec.Error(ctx, err)
 8819		return graphql.Null
 8820	}
 8821	if resTmp == nil {
 8822		return graphql.Null
 8823	}
 8824	res := resTmp.(string)
 8825	fc.Result = res
 8826	return ec.marshalOString2string(ctx, field.Selections, res)
 8827}
 8828
 8829func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8830	defer func() {
 8831		if r := recover(); r != nil {
 8832			ec.Error(ctx, ec.Recover(ctx, r))
 8833			ret = graphql.Null
 8834		}
 8835	}()
 8836	fc := &graphql.FieldContext{
 8837		Object:   "__Directive",
 8838		Field:    field,
 8839		Args:     nil,
 8840		IsMethod: false,
 8841	}
 8842
 8843	ctx = graphql.WithFieldContext(ctx, fc)
 8844	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8845		ctx = rctx // use context from middleware stack in children
 8846		return obj.Locations, nil
 8847	})
 8848	if err != nil {
 8849		ec.Error(ctx, err)
 8850		return graphql.Null
 8851	}
 8852	if resTmp == nil {
 8853		if !graphql.HasFieldError(ctx, fc) {
 8854			ec.Errorf(ctx, "must not be null")
 8855		}
 8856		return graphql.Null
 8857	}
 8858	res := resTmp.([]string)
 8859	fc.Result = res
 8860	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 8861}
 8862
 8863func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 8864	defer func() {
 8865		if r := recover(); r != nil {
 8866			ec.Error(ctx, ec.Recover(ctx, r))
 8867			ret = graphql.Null
 8868		}
 8869	}()
 8870	fc := &graphql.FieldContext{
 8871		Object:   "__Directive",
 8872		Field:    field,
 8873		Args:     nil,
 8874		IsMethod: false,
 8875	}
 8876
 8877	ctx = graphql.WithFieldContext(ctx, fc)
 8878	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8879		ctx = rctx // use context from middleware stack in children
 8880		return obj.Args, nil
 8881	})
 8882	if err != nil {
 8883		ec.Error(ctx, err)
 8884		return graphql.Null
 8885	}
 8886	if resTmp == nil {
 8887		if !graphql.HasFieldError(ctx, fc) {
 8888			ec.Errorf(ctx, "must not be null")
 8889		}
 8890		return graphql.Null
 8891	}
 8892	res := resTmp.([]introspection.InputValue)
 8893	fc.Result = res
 8894	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 8895}
 8896
 8897func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8898	defer func() {
 8899		if r := recover(); r != nil {
 8900			ec.Error(ctx, ec.Recover(ctx, r))
 8901			ret = graphql.Null
 8902		}
 8903	}()
 8904	fc := &graphql.FieldContext{
 8905		Object:   "__EnumValue",
 8906		Field:    field,
 8907		Args:     nil,
 8908		IsMethod: false,
 8909	}
 8910
 8911	ctx = graphql.WithFieldContext(ctx, fc)
 8912	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8913		ctx = rctx // use context from middleware stack in children
 8914		return obj.Name, nil
 8915	})
 8916	if err != nil {
 8917		ec.Error(ctx, err)
 8918		return graphql.Null
 8919	}
 8920	if resTmp == nil {
 8921		if !graphql.HasFieldError(ctx, fc) {
 8922			ec.Errorf(ctx, "must not be null")
 8923		}
 8924		return graphql.Null
 8925	}
 8926	res := resTmp.(string)
 8927	fc.Result = res
 8928	return ec.marshalNString2string(ctx, field.Selections, res)
 8929}
 8930
 8931func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8932	defer func() {
 8933		if r := recover(); r != nil {
 8934			ec.Error(ctx, ec.Recover(ctx, r))
 8935			ret = graphql.Null
 8936		}
 8937	}()
 8938	fc := &graphql.FieldContext{
 8939		Object:   "__EnumValue",
 8940		Field:    field,
 8941		Args:     nil,
 8942		IsMethod: false,
 8943	}
 8944
 8945	ctx = graphql.WithFieldContext(ctx, fc)
 8946	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8947		ctx = rctx // use context from middleware stack in children
 8948		return obj.Description, nil
 8949	})
 8950	if err != nil {
 8951		ec.Error(ctx, err)
 8952		return graphql.Null
 8953	}
 8954	if resTmp == nil {
 8955		return graphql.Null
 8956	}
 8957	res := resTmp.(string)
 8958	fc.Result = res
 8959	return ec.marshalOString2string(ctx, field.Selections, res)
 8960}
 8961
 8962func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8963	defer func() {
 8964		if r := recover(); r != nil {
 8965			ec.Error(ctx, ec.Recover(ctx, r))
 8966			ret = graphql.Null
 8967		}
 8968	}()
 8969	fc := &graphql.FieldContext{
 8970		Object:   "__EnumValue",
 8971		Field:    field,
 8972		Args:     nil,
 8973		IsMethod: true,
 8974	}
 8975
 8976	ctx = graphql.WithFieldContext(ctx, fc)
 8977	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8978		ctx = rctx // use context from middleware stack in children
 8979		return obj.IsDeprecated(), nil
 8980	})
 8981	if err != nil {
 8982		ec.Error(ctx, err)
 8983		return graphql.Null
 8984	}
 8985	if resTmp == nil {
 8986		if !graphql.HasFieldError(ctx, fc) {
 8987			ec.Errorf(ctx, "must not be null")
 8988		}
 8989		return graphql.Null
 8990	}
 8991	res := resTmp.(bool)
 8992	fc.Result = res
 8993	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 8994}
 8995
 8996func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 8997	defer func() {
 8998		if r := recover(); r != nil {
 8999			ec.Error(ctx, ec.Recover(ctx, r))
 9000			ret = graphql.Null
 9001		}
 9002	}()
 9003	fc := &graphql.FieldContext{
 9004		Object:   "__EnumValue",
 9005		Field:    field,
 9006		Args:     nil,
 9007		IsMethod: true,
 9008	}
 9009
 9010	ctx = graphql.WithFieldContext(ctx, fc)
 9011	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9012		ctx = rctx // use context from middleware stack in children
 9013		return obj.DeprecationReason(), nil
 9014	})
 9015	if err != nil {
 9016		ec.Error(ctx, err)
 9017		return graphql.Null
 9018	}
 9019	if resTmp == nil {
 9020		return graphql.Null
 9021	}
 9022	res := resTmp.(*string)
 9023	fc.Result = res
 9024	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9025}
 9026
 9027func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9028	defer func() {
 9029		if r := recover(); r != nil {
 9030			ec.Error(ctx, ec.Recover(ctx, r))
 9031			ret = graphql.Null
 9032		}
 9033	}()
 9034	fc := &graphql.FieldContext{
 9035		Object:   "__Field",
 9036		Field:    field,
 9037		Args:     nil,
 9038		IsMethod: false,
 9039	}
 9040
 9041	ctx = graphql.WithFieldContext(ctx, fc)
 9042	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9043		ctx = rctx // use context from middleware stack in children
 9044		return obj.Name, nil
 9045	})
 9046	if err != nil {
 9047		ec.Error(ctx, err)
 9048		return graphql.Null
 9049	}
 9050	if resTmp == nil {
 9051		if !graphql.HasFieldError(ctx, fc) {
 9052			ec.Errorf(ctx, "must not be null")
 9053		}
 9054		return graphql.Null
 9055	}
 9056	res := resTmp.(string)
 9057	fc.Result = res
 9058	return ec.marshalNString2string(ctx, field.Selections, res)
 9059}
 9060
 9061func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9062	defer func() {
 9063		if r := recover(); r != nil {
 9064			ec.Error(ctx, ec.Recover(ctx, r))
 9065			ret = graphql.Null
 9066		}
 9067	}()
 9068	fc := &graphql.FieldContext{
 9069		Object:   "__Field",
 9070		Field:    field,
 9071		Args:     nil,
 9072		IsMethod: false,
 9073	}
 9074
 9075	ctx = graphql.WithFieldContext(ctx, fc)
 9076	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9077		ctx = rctx // use context from middleware stack in children
 9078		return obj.Description, nil
 9079	})
 9080	if err != nil {
 9081		ec.Error(ctx, err)
 9082		return graphql.Null
 9083	}
 9084	if resTmp == nil {
 9085		return graphql.Null
 9086	}
 9087	res := resTmp.(string)
 9088	fc.Result = res
 9089	return ec.marshalOString2string(ctx, field.Selections, res)
 9090}
 9091
 9092func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9093	defer func() {
 9094		if r := recover(); r != nil {
 9095			ec.Error(ctx, ec.Recover(ctx, r))
 9096			ret = graphql.Null
 9097		}
 9098	}()
 9099	fc := &graphql.FieldContext{
 9100		Object:   "__Field",
 9101		Field:    field,
 9102		Args:     nil,
 9103		IsMethod: false,
 9104	}
 9105
 9106	ctx = graphql.WithFieldContext(ctx, fc)
 9107	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9108		ctx = rctx // use context from middleware stack in children
 9109		return obj.Args, nil
 9110	})
 9111	if err != nil {
 9112		ec.Error(ctx, err)
 9113		return graphql.Null
 9114	}
 9115	if resTmp == nil {
 9116		if !graphql.HasFieldError(ctx, fc) {
 9117			ec.Errorf(ctx, "must not be null")
 9118		}
 9119		return graphql.Null
 9120	}
 9121	res := resTmp.([]introspection.InputValue)
 9122	fc.Result = res
 9123	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9124}
 9125
 9126func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9127	defer func() {
 9128		if r := recover(); r != nil {
 9129			ec.Error(ctx, ec.Recover(ctx, r))
 9130			ret = graphql.Null
 9131		}
 9132	}()
 9133	fc := &graphql.FieldContext{
 9134		Object:   "__Field",
 9135		Field:    field,
 9136		Args:     nil,
 9137		IsMethod: false,
 9138	}
 9139
 9140	ctx = graphql.WithFieldContext(ctx, fc)
 9141	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9142		ctx = rctx // use context from middleware stack in children
 9143		return obj.Type, nil
 9144	})
 9145	if err != nil {
 9146		ec.Error(ctx, err)
 9147		return graphql.Null
 9148	}
 9149	if resTmp == nil {
 9150		if !graphql.HasFieldError(ctx, fc) {
 9151			ec.Errorf(ctx, "must not be null")
 9152		}
 9153		return graphql.Null
 9154	}
 9155	res := resTmp.(*introspection.Type)
 9156	fc.Result = res
 9157	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9158}
 9159
 9160func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9161	defer func() {
 9162		if r := recover(); r != nil {
 9163			ec.Error(ctx, ec.Recover(ctx, r))
 9164			ret = graphql.Null
 9165		}
 9166	}()
 9167	fc := &graphql.FieldContext{
 9168		Object:   "__Field",
 9169		Field:    field,
 9170		Args:     nil,
 9171		IsMethod: true,
 9172	}
 9173
 9174	ctx = graphql.WithFieldContext(ctx, fc)
 9175	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9176		ctx = rctx // use context from middleware stack in children
 9177		return obj.IsDeprecated(), nil
 9178	})
 9179	if err != nil {
 9180		ec.Error(ctx, err)
 9181		return graphql.Null
 9182	}
 9183	if resTmp == nil {
 9184		if !graphql.HasFieldError(ctx, fc) {
 9185			ec.Errorf(ctx, "must not be null")
 9186		}
 9187		return graphql.Null
 9188	}
 9189	res := resTmp.(bool)
 9190	fc.Result = res
 9191	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9192}
 9193
 9194func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9195	defer func() {
 9196		if r := recover(); r != nil {
 9197			ec.Error(ctx, ec.Recover(ctx, r))
 9198			ret = graphql.Null
 9199		}
 9200	}()
 9201	fc := &graphql.FieldContext{
 9202		Object:   "__Field",
 9203		Field:    field,
 9204		Args:     nil,
 9205		IsMethod: true,
 9206	}
 9207
 9208	ctx = graphql.WithFieldContext(ctx, fc)
 9209	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9210		ctx = rctx // use context from middleware stack in children
 9211		return obj.DeprecationReason(), nil
 9212	})
 9213	if err != nil {
 9214		ec.Error(ctx, err)
 9215		return graphql.Null
 9216	}
 9217	if resTmp == nil {
 9218		return graphql.Null
 9219	}
 9220	res := resTmp.(*string)
 9221	fc.Result = res
 9222	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9223}
 9224
 9225func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9226	defer func() {
 9227		if r := recover(); r != nil {
 9228			ec.Error(ctx, ec.Recover(ctx, r))
 9229			ret = graphql.Null
 9230		}
 9231	}()
 9232	fc := &graphql.FieldContext{
 9233		Object:   "__InputValue",
 9234		Field:    field,
 9235		Args:     nil,
 9236		IsMethod: false,
 9237	}
 9238
 9239	ctx = graphql.WithFieldContext(ctx, fc)
 9240	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9241		ctx = rctx // use context from middleware stack in children
 9242		return obj.Name, nil
 9243	})
 9244	if err != nil {
 9245		ec.Error(ctx, err)
 9246		return graphql.Null
 9247	}
 9248	if resTmp == nil {
 9249		if !graphql.HasFieldError(ctx, fc) {
 9250			ec.Errorf(ctx, "must not be null")
 9251		}
 9252		return graphql.Null
 9253	}
 9254	res := resTmp.(string)
 9255	fc.Result = res
 9256	return ec.marshalNString2string(ctx, field.Selections, res)
 9257}
 9258
 9259func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9260	defer func() {
 9261		if r := recover(); r != nil {
 9262			ec.Error(ctx, ec.Recover(ctx, r))
 9263			ret = graphql.Null
 9264		}
 9265	}()
 9266	fc := &graphql.FieldContext{
 9267		Object:   "__InputValue",
 9268		Field:    field,
 9269		Args:     nil,
 9270		IsMethod: false,
 9271	}
 9272
 9273	ctx = graphql.WithFieldContext(ctx, fc)
 9274	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9275		ctx = rctx // use context from middleware stack in children
 9276		return obj.Description, nil
 9277	})
 9278	if err != nil {
 9279		ec.Error(ctx, err)
 9280		return graphql.Null
 9281	}
 9282	if resTmp == nil {
 9283		return graphql.Null
 9284	}
 9285	res := resTmp.(string)
 9286	fc.Result = res
 9287	return ec.marshalOString2string(ctx, field.Selections, res)
 9288}
 9289
 9290func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9291	defer func() {
 9292		if r := recover(); r != nil {
 9293			ec.Error(ctx, ec.Recover(ctx, r))
 9294			ret = graphql.Null
 9295		}
 9296	}()
 9297	fc := &graphql.FieldContext{
 9298		Object:   "__InputValue",
 9299		Field:    field,
 9300		Args:     nil,
 9301		IsMethod: false,
 9302	}
 9303
 9304	ctx = graphql.WithFieldContext(ctx, fc)
 9305	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9306		ctx = rctx // use context from middleware stack in children
 9307		return obj.Type, nil
 9308	})
 9309	if err != nil {
 9310		ec.Error(ctx, err)
 9311		return graphql.Null
 9312	}
 9313	if resTmp == nil {
 9314		if !graphql.HasFieldError(ctx, fc) {
 9315			ec.Errorf(ctx, "must not be null")
 9316		}
 9317		return graphql.Null
 9318	}
 9319	res := resTmp.(*introspection.Type)
 9320	fc.Result = res
 9321	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9322}
 9323
 9324func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9325	defer func() {
 9326		if r := recover(); r != nil {
 9327			ec.Error(ctx, ec.Recover(ctx, r))
 9328			ret = graphql.Null
 9329		}
 9330	}()
 9331	fc := &graphql.FieldContext{
 9332		Object:   "__InputValue",
 9333		Field:    field,
 9334		Args:     nil,
 9335		IsMethod: false,
 9336	}
 9337
 9338	ctx = graphql.WithFieldContext(ctx, fc)
 9339	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9340		ctx = rctx // use context from middleware stack in children
 9341		return obj.DefaultValue, nil
 9342	})
 9343	if err != nil {
 9344		ec.Error(ctx, err)
 9345		return graphql.Null
 9346	}
 9347	if resTmp == nil {
 9348		return graphql.Null
 9349	}
 9350	res := resTmp.(*string)
 9351	fc.Result = res
 9352	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9353}
 9354
 9355func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9356	defer func() {
 9357		if r := recover(); r != nil {
 9358			ec.Error(ctx, ec.Recover(ctx, r))
 9359			ret = graphql.Null
 9360		}
 9361	}()
 9362	fc := &graphql.FieldContext{
 9363		Object:   "__Schema",
 9364		Field:    field,
 9365		Args:     nil,
 9366		IsMethod: true,
 9367	}
 9368
 9369	ctx = graphql.WithFieldContext(ctx, fc)
 9370	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9371		ctx = rctx // use context from middleware stack in children
 9372		return obj.Types(), nil
 9373	})
 9374	if err != nil {
 9375		ec.Error(ctx, err)
 9376		return graphql.Null
 9377	}
 9378	if resTmp == nil {
 9379		if !graphql.HasFieldError(ctx, fc) {
 9380			ec.Errorf(ctx, "must not be null")
 9381		}
 9382		return graphql.Null
 9383	}
 9384	res := resTmp.([]introspection.Type)
 9385	fc.Result = res
 9386	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9387}
 9388
 9389func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9390	defer func() {
 9391		if r := recover(); r != nil {
 9392			ec.Error(ctx, ec.Recover(ctx, r))
 9393			ret = graphql.Null
 9394		}
 9395	}()
 9396	fc := &graphql.FieldContext{
 9397		Object:   "__Schema",
 9398		Field:    field,
 9399		Args:     nil,
 9400		IsMethod: true,
 9401	}
 9402
 9403	ctx = graphql.WithFieldContext(ctx, fc)
 9404	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9405		ctx = rctx // use context from middleware stack in children
 9406		return obj.QueryType(), nil
 9407	})
 9408	if err != nil {
 9409		ec.Error(ctx, err)
 9410		return graphql.Null
 9411	}
 9412	if resTmp == nil {
 9413		if !graphql.HasFieldError(ctx, fc) {
 9414			ec.Errorf(ctx, "must not be null")
 9415		}
 9416		return graphql.Null
 9417	}
 9418	res := resTmp.(*introspection.Type)
 9419	fc.Result = res
 9420	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9421}
 9422
 9423func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9424	defer func() {
 9425		if r := recover(); r != nil {
 9426			ec.Error(ctx, ec.Recover(ctx, r))
 9427			ret = graphql.Null
 9428		}
 9429	}()
 9430	fc := &graphql.FieldContext{
 9431		Object:   "__Schema",
 9432		Field:    field,
 9433		Args:     nil,
 9434		IsMethod: true,
 9435	}
 9436
 9437	ctx = graphql.WithFieldContext(ctx, fc)
 9438	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9439		ctx = rctx // use context from middleware stack in children
 9440		return obj.MutationType(), nil
 9441	})
 9442	if err != nil {
 9443		ec.Error(ctx, err)
 9444		return graphql.Null
 9445	}
 9446	if resTmp == nil {
 9447		return graphql.Null
 9448	}
 9449	res := resTmp.(*introspection.Type)
 9450	fc.Result = res
 9451	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9452}
 9453
 9454func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9455	defer func() {
 9456		if r := recover(); r != nil {
 9457			ec.Error(ctx, ec.Recover(ctx, r))
 9458			ret = graphql.Null
 9459		}
 9460	}()
 9461	fc := &graphql.FieldContext{
 9462		Object:   "__Schema",
 9463		Field:    field,
 9464		Args:     nil,
 9465		IsMethod: true,
 9466	}
 9467
 9468	ctx = graphql.WithFieldContext(ctx, fc)
 9469	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9470		ctx = rctx // use context from middleware stack in children
 9471		return obj.SubscriptionType(), nil
 9472	})
 9473	if err != nil {
 9474		ec.Error(ctx, err)
 9475		return graphql.Null
 9476	}
 9477	if resTmp == nil {
 9478		return graphql.Null
 9479	}
 9480	res := resTmp.(*introspection.Type)
 9481	fc.Result = res
 9482	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9483}
 9484
 9485func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9486	defer func() {
 9487		if r := recover(); r != nil {
 9488			ec.Error(ctx, ec.Recover(ctx, r))
 9489			ret = graphql.Null
 9490		}
 9491	}()
 9492	fc := &graphql.FieldContext{
 9493		Object:   "__Schema",
 9494		Field:    field,
 9495		Args:     nil,
 9496		IsMethod: true,
 9497	}
 9498
 9499	ctx = graphql.WithFieldContext(ctx, fc)
 9500	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9501		ctx = rctx // use context from middleware stack in children
 9502		return obj.Directives(), nil
 9503	})
 9504	if err != nil {
 9505		ec.Error(ctx, err)
 9506		return graphql.Null
 9507	}
 9508	if resTmp == nil {
 9509		if !graphql.HasFieldError(ctx, fc) {
 9510			ec.Errorf(ctx, "must not be null")
 9511		}
 9512		return graphql.Null
 9513	}
 9514	res := resTmp.([]introspection.Directive)
 9515	fc.Result = res
 9516	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
 9517}
 9518
 9519func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9520	defer func() {
 9521		if r := recover(); r != nil {
 9522			ec.Error(ctx, ec.Recover(ctx, r))
 9523			ret = graphql.Null
 9524		}
 9525	}()
 9526	fc := &graphql.FieldContext{
 9527		Object:   "__Type",
 9528		Field:    field,
 9529		Args:     nil,
 9530		IsMethod: true,
 9531	}
 9532
 9533	ctx = graphql.WithFieldContext(ctx, fc)
 9534	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9535		ctx = rctx // use context from middleware stack in children
 9536		return obj.Kind(), nil
 9537	})
 9538	if err != nil {
 9539		ec.Error(ctx, err)
 9540		return graphql.Null
 9541	}
 9542	if resTmp == nil {
 9543		if !graphql.HasFieldError(ctx, fc) {
 9544			ec.Errorf(ctx, "must not be null")
 9545		}
 9546		return graphql.Null
 9547	}
 9548	res := resTmp.(string)
 9549	fc.Result = res
 9550	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 9551}
 9552
 9553func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9554	defer func() {
 9555		if r := recover(); r != nil {
 9556			ec.Error(ctx, ec.Recover(ctx, r))
 9557			ret = graphql.Null
 9558		}
 9559	}()
 9560	fc := &graphql.FieldContext{
 9561		Object:   "__Type",
 9562		Field:    field,
 9563		Args:     nil,
 9564		IsMethod: true,
 9565	}
 9566
 9567	ctx = graphql.WithFieldContext(ctx, fc)
 9568	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9569		ctx = rctx // use context from middleware stack in children
 9570		return obj.Name(), nil
 9571	})
 9572	if err != nil {
 9573		ec.Error(ctx, err)
 9574		return graphql.Null
 9575	}
 9576	if resTmp == nil {
 9577		return graphql.Null
 9578	}
 9579	res := resTmp.(*string)
 9580	fc.Result = res
 9581	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9582}
 9583
 9584func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9585	defer func() {
 9586		if r := recover(); r != nil {
 9587			ec.Error(ctx, ec.Recover(ctx, r))
 9588			ret = graphql.Null
 9589		}
 9590	}()
 9591	fc := &graphql.FieldContext{
 9592		Object:   "__Type",
 9593		Field:    field,
 9594		Args:     nil,
 9595		IsMethod: true,
 9596	}
 9597
 9598	ctx = graphql.WithFieldContext(ctx, fc)
 9599	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9600		ctx = rctx // use context from middleware stack in children
 9601		return obj.Description(), nil
 9602	})
 9603	if err != nil {
 9604		ec.Error(ctx, err)
 9605		return graphql.Null
 9606	}
 9607	if resTmp == nil {
 9608		return graphql.Null
 9609	}
 9610	res := resTmp.(string)
 9611	fc.Result = res
 9612	return ec.marshalOString2string(ctx, field.Selections, res)
 9613}
 9614
 9615func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9616	defer func() {
 9617		if r := recover(); r != nil {
 9618			ec.Error(ctx, ec.Recover(ctx, r))
 9619			ret = graphql.Null
 9620		}
 9621	}()
 9622	fc := &graphql.FieldContext{
 9623		Object:   "__Type",
 9624		Field:    field,
 9625		Args:     nil,
 9626		IsMethod: true,
 9627	}
 9628
 9629	ctx = graphql.WithFieldContext(ctx, fc)
 9630	rawArgs := field.ArgumentMap(ec.Variables)
 9631	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 9632	if err != nil {
 9633		ec.Error(ctx, err)
 9634		return graphql.Null
 9635	}
 9636	fc.Args = args
 9637	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9638		ctx = rctx // use context from middleware stack in children
 9639		return obj.Fields(args["includeDeprecated"].(bool)), nil
 9640	})
 9641	if err != nil {
 9642		ec.Error(ctx, err)
 9643		return graphql.Null
 9644	}
 9645	if resTmp == nil {
 9646		return graphql.Null
 9647	}
 9648	res := resTmp.([]introspection.Field)
 9649	fc.Result = res
 9650	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
 9651}
 9652
 9653func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9654	defer func() {
 9655		if r := recover(); r != nil {
 9656			ec.Error(ctx, ec.Recover(ctx, r))
 9657			ret = graphql.Null
 9658		}
 9659	}()
 9660	fc := &graphql.FieldContext{
 9661		Object:   "__Type",
 9662		Field:    field,
 9663		Args:     nil,
 9664		IsMethod: true,
 9665	}
 9666
 9667	ctx = graphql.WithFieldContext(ctx, fc)
 9668	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9669		ctx = rctx // use context from middleware stack in children
 9670		return obj.Interfaces(), nil
 9671	})
 9672	if err != nil {
 9673		ec.Error(ctx, err)
 9674		return graphql.Null
 9675	}
 9676	if resTmp == nil {
 9677		return graphql.Null
 9678	}
 9679	res := resTmp.([]introspection.Type)
 9680	fc.Result = res
 9681	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9682}
 9683
 9684func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9685	defer func() {
 9686		if r := recover(); r != nil {
 9687			ec.Error(ctx, ec.Recover(ctx, r))
 9688			ret = graphql.Null
 9689		}
 9690	}()
 9691	fc := &graphql.FieldContext{
 9692		Object:   "__Type",
 9693		Field:    field,
 9694		Args:     nil,
 9695		IsMethod: true,
 9696	}
 9697
 9698	ctx = graphql.WithFieldContext(ctx, fc)
 9699	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9700		ctx = rctx // use context from middleware stack in children
 9701		return obj.PossibleTypes(), nil
 9702	})
 9703	if err != nil {
 9704		ec.Error(ctx, err)
 9705		return graphql.Null
 9706	}
 9707	if resTmp == nil {
 9708		return graphql.Null
 9709	}
 9710	res := resTmp.([]introspection.Type)
 9711	fc.Result = res
 9712	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9713}
 9714
 9715func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9716	defer func() {
 9717		if r := recover(); r != nil {
 9718			ec.Error(ctx, ec.Recover(ctx, r))
 9719			ret = graphql.Null
 9720		}
 9721	}()
 9722	fc := &graphql.FieldContext{
 9723		Object:   "__Type",
 9724		Field:    field,
 9725		Args:     nil,
 9726		IsMethod: true,
 9727	}
 9728
 9729	ctx = graphql.WithFieldContext(ctx, fc)
 9730	rawArgs := field.ArgumentMap(ec.Variables)
 9731	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
 9732	if err != nil {
 9733		ec.Error(ctx, err)
 9734		return graphql.Null
 9735	}
 9736	fc.Args = args
 9737	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9738		ctx = rctx // use context from middleware stack in children
 9739		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
 9740	})
 9741	if err != nil {
 9742		ec.Error(ctx, err)
 9743		return graphql.Null
 9744	}
 9745	if resTmp == nil {
 9746		return graphql.Null
 9747	}
 9748	res := resTmp.([]introspection.EnumValue)
 9749	fc.Result = res
 9750	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
 9751}
 9752
 9753func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9754	defer func() {
 9755		if r := recover(); r != nil {
 9756			ec.Error(ctx, ec.Recover(ctx, r))
 9757			ret = graphql.Null
 9758		}
 9759	}()
 9760	fc := &graphql.FieldContext{
 9761		Object:   "__Type",
 9762		Field:    field,
 9763		Args:     nil,
 9764		IsMethod: true,
 9765	}
 9766
 9767	ctx = graphql.WithFieldContext(ctx, fc)
 9768	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9769		ctx = rctx // use context from middleware stack in children
 9770		return obj.InputFields(), nil
 9771	})
 9772	if err != nil {
 9773		ec.Error(ctx, err)
 9774		return graphql.Null
 9775	}
 9776	if resTmp == nil {
 9777		return graphql.Null
 9778	}
 9779	res := resTmp.([]introspection.InputValue)
 9780	fc.Result = res
 9781	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9782}
 9783
 9784func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9785	defer func() {
 9786		if r := recover(); r != nil {
 9787			ec.Error(ctx, ec.Recover(ctx, r))
 9788			ret = graphql.Null
 9789		}
 9790	}()
 9791	fc := &graphql.FieldContext{
 9792		Object:   "__Type",
 9793		Field:    field,
 9794		Args:     nil,
 9795		IsMethod: true,
 9796	}
 9797
 9798	ctx = graphql.WithFieldContext(ctx, fc)
 9799	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9800		ctx = rctx // use context from middleware stack in children
 9801		return obj.OfType(), nil
 9802	})
 9803	if err != nil {
 9804		ec.Error(ctx, err)
 9805		return graphql.Null
 9806	}
 9807	if resTmp == nil {
 9808		return graphql.Null
 9809	}
 9810	res := resTmp.(*introspection.Type)
 9811	fc.Result = res
 9812	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9813}
 9814
 9815// endregion **************************** field.gotpl *****************************
 9816
 9817// region    **************************** input.gotpl *****************************
 9818
 9819func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
 9820	var it models.AddCommentInput
 9821	var asMap = obj.(map[string]interface{})
 9822
 9823	for k, v := range asMap {
 9824		switch k {
 9825		case "clientMutationId":
 9826			var err error
 9827			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9828			if err != nil {
 9829				return it, err
 9830			}
 9831		case "repoRef":
 9832			var err error
 9833			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9834			if err != nil {
 9835				return it, err
 9836			}
 9837		case "prefix":
 9838			var err error
 9839			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9840			if err != nil {
 9841				return it, err
 9842			}
 9843		case "message":
 9844			var err error
 9845			it.Message, err = ec.unmarshalNString2string(ctx, v)
 9846			if err != nil {
 9847				return it, err
 9848			}
 9849		case "files":
 9850			var err error
 9851			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
 9852			if err != nil {
 9853				return it, err
 9854			}
 9855		}
 9856	}
 9857
 9858	return it, nil
 9859}
 9860
 9861func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
 9862	var it models.ChangeLabelInput
 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 "added":
 9886			var err error
 9887			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9888			if err != nil {
 9889				return it, err
 9890			}
 9891		case "Removed":
 9892			var err error
 9893			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
 9894			if err != nil {
 9895				return it, err
 9896			}
 9897		}
 9898	}
 9899
 9900	return it, nil
 9901}
 9902
 9903func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
 9904	var it models.CloseBugInput
 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		}
 9928	}
 9929
 9930	return it, nil
 9931}
 9932
 9933func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
 9934	var it models.NewBugInput
 9935	var asMap = obj.(map[string]interface{})
 9936
 9937	for k, v := range asMap {
 9938		switch k {
 9939		case "clientMutationId":
 9940			var err error
 9941			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9942			if err != nil {
 9943				return it, err
 9944			}
 9945		case "repoRef":
 9946			var err error
 9947			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 9948			if err != nil {
 9949				return it, err
 9950			}
 9951		case "title":
 9952			var err error
 9953			it.Title, err = ec.unmarshalNString2string(ctx, v)
 9954			if err != nil {
 9955				return it, err
 9956			}
 9957		case "message":
 9958			var err error
 9959			it.Message, err = ec.unmarshalNString2string(ctx, v)
 9960			if err != nil {
 9961				return it, err
 9962			}
 9963		case "files":
 9964			var err error
 9965			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
 9966			if err != nil {
 9967				return it, err
 9968			}
 9969		}
 9970	}
 9971
 9972	return it, nil
 9973}
 9974
 9975func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
 9976	var it models.OpenBugInput
 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 "prefix":
 9994			var err error
 9995			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 9996			if err != nil {
 9997				return it, err
 9998			}
 9999		}
10000	}
10001
10002	return it, nil
10003}
10004
10005func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10006	var it models.SetTitleInput
10007	var asMap = obj.(map[string]interface{})
10008
10009	for k, v := range asMap {
10010		switch k {
10011		case "clientMutationId":
10012			var err error
10013			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10014			if err != nil {
10015				return it, err
10016			}
10017		case "repoRef":
10018			var err error
10019			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10020			if err != nil {
10021				return it, err
10022			}
10023		case "prefix":
10024			var err error
10025			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10026			if err != nil {
10027				return it, err
10028			}
10029		case "title":
10030			var err error
10031			it.Title, err = ec.unmarshalNString2string(ctx, v)
10032			if err != nil {
10033				return it, err
10034			}
10035		}
10036	}
10037
10038	return it, nil
10039}
10040
10041// endregion **************************** input.gotpl *****************************
10042
10043// region    ************************** interface.gotpl ***************************
10044
10045func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10046	switch obj := (obj).(type) {
10047	case nil:
10048		return graphql.Null
10049	case bug.Comment:
10050		return ec._Comment(ctx, sel, &obj)
10051	case *bug.Comment:
10052		if obj == nil {
10053			return graphql.Null
10054		}
10055		return ec._Comment(ctx, sel, obj)
10056	case models.BugWrapper:
10057		if obj == nil {
10058			return graphql.Null
10059		}
10060		return ec._Bug(ctx, sel, obj)
10061	case *bug.CreateOperation:
10062		if obj == nil {
10063			return graphql.Null
10064		}
10065		return ec._CreateOperation(ctx, sel, obj)
10066	case *bug.SetTitleOperation:
10067		if obj == nil {
10068			return graphql.Null
10069		}
10070		return ec._SetTitleOperation(ctx, sel, obj)
10071	case *bug.AddCommentOperation:
10072		if obj == nil {
10073			return graphql.Null
10074		}
10075		return ec._AddCommentOperation(ctx, sel, obj)
10076	case *bug.EditCommentOperation:
10077		if obj == nil {
10078			return graphql.Null
10079		}
10080		return ec._EditCommentOperation(ctx, sel, obj)
10081	case *bug.SetStatusOperation:
10082		if obj == nil {
10083			return graphql.Null
10084		}
10085		return ec._SetStatusOperation(ctx, sel, obj)
10086	case *bug.LabelChangeOperation:
10087		if obj == nil {
10088			return graphql.Null
10089		}
10090		return ec._LabelChangeOperation(ctx, sel, obj)
10091	case *bug.CreateTimelineItem:
10092		if obj == nil {
10093			return graphql.Null
10094		}
10095		return ec._CreateTimelineItem(ctx, sel, obj)
10096	case *bug.AddCommentTimelineItem:
10097		if obj == nil {
10098			return graphql.Null
10099		}
10100		return ec._AddCommentTimelineItem(ctx, sel, obj)
10101	case *bug.LabelChangeTimelineItem:
10102		if obj == nil {
10103			return graphql.Null
10104		}
10105		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10106	case *bug.SetStatusTimelineItem:
10107		if obj == nil {
10108			return graphql.Null
10109		}
10110		return ec._SetStatusTimelineItem(ctx, sel, obj)
10111	case *bug.SetTitleTimelineItem:
10112		if obj == nil {
10113			return graphql.Null
10114		}
10115		return ec._SetTitleTimelineItem(ctx, sel, obj)
10116	default:
10117		panic(fmt.Errorf("unexpected type %T", obj))
10118	}
10119}
10120
10121func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10122	switch obj := (obj).(type) {
10123	case nil:
10124		return graphql.Null
10125	case *bug.CreateOperation:
10126		if obj == nil {
10127			return graphql.Null
10128		}
10129		return ec._CreateOperation(ctx, sel, obj)
10130	case *bug.SetTitleOperation:
10131		if obj == nil {
10132			return graphql.Null
10133		}
10134		return ec._SetTitleOperation(ctx, sel, obj)
10135	case *bug.AddCommentOperation:
10136		if obj == nil {
10137			return graphql.Null
10138		}
10139		return ec._AddCommentOperation(ctx, sel, obj)
10140	case *bug.EditCommentOperation:
10141		if obj == nil {
10142			return graphql.Null
10143		}
10144		return ec._EditCommentOperation(ctx, sel, obj)
10145	case *bug.SetStatusOperation:
10146		if obj == nil {
10147			return graphql.Null
10148		}
10149		return ec._SetStatusOperation(ctx, sel, obj)
10150	case *bug.LabelChangeOperation:
10151		if obj == nil {
10152			return graphql.Null
10153		}
10154		return ec._LabelChangeOperation(ctx, sel, obj)
10155	default:
10156		panic(fmt.Errorf("unexpected type %T", obj))
10157	}
10158}
10159
10160func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10161	switch obj := (obj).(type) {
10162	case nil:
10163		return graphql.Null
10164	case *bug.CreateTimelineItem:
10165		if obj == nil {
10166			return graphql.Null
10167		}
10168		return ec._CreateTimelineItem(ctx, sel, obj)
10169	case *bug.AddCommentTimelineItem:
10170		if obj == nil {
10171			return graphql.Null
10172		}
10173		return ec._AddCommentTimelineItem(ctx, sel, obj)
10174	case bug.LabelChangeTimelineItem:
10175		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10176	case *bug.LabelChangeTimelineItem:
10177		if obj == nil {
10178			return graphql.Null
10179		}
10180		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10181	case bug.SetStatusTimelineItem:
10182		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10183	case *bug.SetStatusTimelineItem:
10184		if obj == nil {
10185			return graphql.Null
10186		}
10187		return ec._SetStatusTimelineItem(ctx, sel, obj)
10188	case bug.SetTitleTimelineItem:
10189		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10190	case *bug.SetTitleTimelineItem:
10191		if obj == nil {
10192			return graphql.Null
10193		}
10194		return ec._SetTitleTimelineItem(ctx, sel, obj)
10195	default:
10196		panic(fmt.Errorf("unexpected type %T", obj))
10197	}
10198}
10199
10200// endregion ************************** interface.gotpl ***************************
10201
10202// region    **************************** object.gotpl ****************************
10203
10204var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10205
10206func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10207	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10208
10209	out := graphql.NewFieldSet(fields)
10210	var invalids uint32
10211	for i, field := range fields {
10212		switch field.Name {
10213		case "__typename":
10214			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10215		case "id":
10216			field := field
10217			out.Concurrently(i, func() (res graphql.Marshaler) {
10218				defer func() {
10219					if r := recover(); r != nil {
10220						ec.Error(ctx, ec.Recover(ctx, r))
10221					}
10222				}()
10223				res = ec._AddCommentOperation_id(ctx, field, obj)
10224				if res == graphql.Null {
10225					atomic.AddUint32(&invalids, 1)
10226				}
10227				return res
10228			})
10229		case "author":
10230			field := field
10231			out.Concurrently(i, func() (res graphql.Marshaler) {
10232				defer func() {
10233					if r := recover(); r != nil {
10234						ec.Error(ctx, ec.Recover(ctx, r))
10235					}
10236				}()
10237				res = ec._AddCommentOperation_author(ctx, field, obj)
10238				if res == graphql.Null {
10239					atomic.AddUint32(&invalids, 1)
10240				}
10241				return res
10242			})
10243		case "date":
10244			field := field
10245			out.Concurrently(i, func() (res graphql.Marshaler) {
10246				defer func() {
10247					if r := recover(); r != nil {
10248						ec.Error(ctx, ec.Recover(ctx, r))
10249					}
10250				}()
10251				res = ec._AddCommentOperation_date(ctx, field, obj)
10252				if res == graphql.Null {
10253					atomic.AddUint32(&invalids, 1)
10254				}
10255				return res
10256			})
10257		case "message":
10258			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10259			if out.Values[i] == graphql.Null {
10260				atomic.AddUint32(&invalids, 1)
10261			}
10262		case "files":
10263			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10264			if out.Values[i] == graphql.Null {
10265				atomic.AddUint32(&invalids, 1)
10266			}
10267		default:
10268			panic("unknown field " + strconv.Quote(field.Name))
10269		}
10270	}
10271	out.Dispatch()
10272	if invalids > 0 {
10273		return graphql.Null
10274	}
10275	return out
10276}
10277
10278var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10279
10280func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10281	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10282
10283	out := graphql.NewFieldSet(fields)
10284	var invalids uint32
10285	for i, field := range fields {
10286		switch field.Name {
10287		case "__typename":
10288			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10289		case "clientMutationId":
10290			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10291		case "bug":
10292			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10293			if out.Values[i] == graphql.Null {
10294				invalids++
10295			}
10296		case "operation":
10297			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10298			if out.Values[i] == graphql.Null {
10299				invalids++
10300			}
10301		default:
10302			panic("unknown field " + strconv.Quote(field.Name))
10303		}
10304	}
10305	out.Dispatch()
10306	if invalids > 0 {
10307		return graphql.Null
10308	}
10309	return out
10310}
10311
10312var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10313
10314func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10315	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10316
10317	out := graphql.NewFieldSet(fields)
10318	var invalids uint32
10319	for i, field := range fields {
10320		switch field.Name {
10321		case "__typename":
10322			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10323		case "id":
10324			field := field
10325			out.Concurrently(i, func() (res graphql.Marshaler) {
10326				defer func() {
10327					if r := recover(); r != nil {
10328						ec.Error(ctx, ec.Recover(ctx, r))
10329					}
10330				}()
10331				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10332				if res == graphql.Null {
10333					atomic.AddUint32(&invalids, 1)
10334				}
10335				return res
10336			})
10337		case "author":
10338			field := field
10339			out.Concurrently(i, func() (res graphql.Marshaler) {
10340				defer func() {
10341					if r := recover(); r != nil {
10342						ec.Error(ctx, ec.Recover(ctx, r))
10343					}
10344				}()
10345				res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10346				if res == graphql.Null {
10347					atomic.AddUint32(&invalids, 1)
10348				}
10349				return res
10350			})
10351		case "message":
10352			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10353			if out.Values[i] == graphql.Null {
10354				atomic.AddUint32(&invalids, 1)
10355			}
10356		case "messageIsEmpty":
10357			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10358			if out.Values[i] == graphql.Null {
10359				atomic.AddUint32(&invalids, 1)
10360			}
10361		case "files":
10362			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10363			if out.Values[i] == graphql.Null {
10364				atomic.AddUint32(&invalids, 1)
10365			}
10366		case "createdAt":
10367			field := field
10368			out.Concurrently(i, func() (res graphql.Marshaler) {
10369				defer func() {
10370					if r := recover(); r != nil {
10371						ec.Error(ctx, ec.Recover(ctx, r))
10372					}
10373				}()
10374				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10375				if res == graphql.Null {
10376					atomic.AddUint32(&invalids, 1)
10377				}
10378				return res
10379			})
10380		case "lastEdit":
10381			field := field
10382			out.Concurrently(i, func() (res graphql.Marshaler) {
10383				defer func() {
10384					if r := recover(); r != nil {
10385						ec.Error(ctx, ec.Recover(ctx, r))
10386					}
10387				}()
10388				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10389				if res == graphql.Null {
10390					atomic.AddUint32(&invalids, 1)
10391				}
10392				return res
10393			})
10394		case "edited":
10395			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10396			if out.Values[i] == graphql.Null {
10397				atomic.AddUint32(&invalids, 1)
10398			}
10399		case "history":
10400			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10401			if out.Values[i] == graphql.Null {
10402				atomic.AddUint32(&invalids, 1)
10403			}
10404		default:
10405			panic("unknown field " + strconv.Quote(field.Name))
10406		}
10407	}
10408	out.Dispatch()
10409	if invalids > 0 {
10410		return graphql.Null
10411	}
10412	return out
10413}
10414
10415var bugImplementors = []string{"Bug", "Authored"}
10416
10417func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10418	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10419
10420	out := graphql.NewFieldSet(fields)
10421	var invalids uint32
10422	for i, field := range fields {
10423		switch field.Name {
10424		case "__typename":
10425			out.Values[i] = graphql.MarshalString("Bug")
10426		case "id":
10427			field := field
10428			out.Concurrently(i, func() (res graphql.Marshaler) {
10429				defer func() {
10430					if r := recover(); r != nil {
10431						ec.Error(ctx, ec.Recover(ctx, r))
10432					}
10433				}()
10434				res = ec._Bug_id(ctx, field, obj)
10435				if res == graphql.Null {
10436					atomic.AddUint32(&invalids, 1)
10437				}
10438				return res
10439			})
10440		case "humanId":
10441			field := field
10442			out.Concurrently(i, func() (res graphql.Marshaler) {
10443				defer func() {
10444					if r := recover(); r != nil {
10445						ec.Error(ctx, ec.Recover(ctx, r))
10446					}
10447				}()
10448				res = ec._Bug_humanId(ctx, field, obj)
10449				if res == graphql.Null {
10450					atomic.AddUint32(&invalids, 1)
10451				}
10452				return res
10453			})
10454		case "status":
10455			field := field
10456			out.Concurrently(i, func() (res graphql.Marshaler) {
10457				defer func() {
10458					if r := recover(); r != nil {
10459						ec.Error(ctx, ec.Recover(ctx, r))
10460					}
10461				}()
10462				res = ec._Bug_status(ctx, field, obj)
10463				if res == graphql.Null {
10464					atomic.AddUint32(&invalids, 1)
10465				}
10466				return res
10467			})
10468		case "title":
10469			out.Values[i] = ec._Bug_title(ctx, field, obj)
10470			if out.Values[i] == graphql.Null {
10471				atomic.AddUint32(&invalids, 1)
10472			}
10473		case "labels":
10474			out.Values[i] = ec._Bug_labels(ctx, field, obj)
10475			if out.Values[i] == graphql.Null {
10476				atomic.AddUint32(&invalids, 1)
10477			}
10478		case "author":
10479			out.Values[i] = ec._Bug_author(ctx, field, obj)
10480			if out.Values[i] == graphql.Null {
10481				atomic.AddUint32(&invalids, 1)
10482			}
10483		case "createdAt":
10484			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10485			if out.Values[i] == graphql.Null {
10486				atomic.AddUint32(&invalids, 1)
10487			}
10488		case "lastEdit":
10489			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10490			if out.Values[i] == graphql.Null {
10491				atomic.AddUint32(&invalids, 1)
10492			}
10493		case "actors":
10494			field := field
10495			out.Concurrently(i, func() (res graphql.Marshaler) {
10496				defer func() {
10497					if r := recover(); r != nil {
10498						ec.Error(ctx, ec.Recover(ctx, r))
10499					}
10500				}()
10501				res = ec._Bug_actors(ctx, field, obj)
10502				if res == graphql.Null {
10503					atomic.AddUint32(&invalids, 1)
10504				}
10505				return res
10506			})
10507		case "participants":
10508			field := field
10509			out.Concurrently(i, func() (res graphql.Marshaler) {
10510				defer func() {
10511					if r := recover(); r != nil {
10512						ec.Error(ctx, ec.Recover(ctx, r))
10513					}
10514				}()
10515				res = ec._Bug_participants(ctx, field, obj)
10516				if res == graphql.Null {
10517					atomic.AddUint32(&invalids, 1)
10518				}
10519				return res
10520			})
10521		case "comments":
10522			field := field
10523			out.Concurrently(i, func() (res graphql.Marshaler) {
10524				defer func() {
10525					if r := recover(); r != nil {
10526						ec.Error(ctx, ec.Recover(ctx, r))
10527					}
10528				}()
10529				res = ec._Bug_comments(ctx, field, obj)
10530				if res == graphql.Null {
10531					atomic.AddUint32(&invalids, 1)
10532				}
10533				return res
10534			})
10535		case "timeline":
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_timeline(ctx, field, obj)
10544				if res == graphql.Null {
10545					atomic.AddUint32(&invalids, 1)
10546				}
10547				return res
10548			})
10549		case "operations":
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_operations(ctx, field, obj)
10558				if res == graphql.Null {
10559					atomic.AddUint32(&invalids, 1)
10560				}
10561				return res
10562			})
10563		default:
10564			panic("unknown field " + strconv.Quote(field.Name))
10565		}
10566	}
10567	out.Dispatch()
10568	if invalids > 0 {
10569		return graphql.Null
10570	}
10571	return out
10572}
10573
10574var bugConnectionImplementors = []string{"BugConnection"}
10575
10576func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10577	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10578
10579	out := graphql.NewFieldSet(fields)
10580	var invalids uint32
10581	for i, field := range fields {
10582		switch field.Name {
10583		case "__typename":
10584			out.Values[i] = graphql.MarshalString("BugConnection")
10585		case "edges":
10586			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10587			if out.Values[i] == graphql.Null {
10588				invalids++
10589			}
10590		case "nodes":
10591			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10592			if out.Values[i] == graphql.Null {
10593				invalids++
10594			}
10595		case "pageInfo":
10596			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10597			if out.Values[i] == graphql.Null {
10598				invalids++
10599			}
10600		case "totalCount":
10601			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
10602			if out.Values[i] == graphql.Null {
10603				invalids++
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 bugEdgeImplementors = []string{"BugEdge"}
10617
10618func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
10619	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
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("BugEdge")
10627		case "cursor":
10628			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
10629			if out.Values[i] == graphql.Null {
10630				invalids++
10631			}
10632		case "node":
10633			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
10634			if out.Values[i] == graphql.Null {
10635				invalids++
10636			}
10637		default:
10638			panic("unknown field " + strconv.Quote(field.Name))
10639		}
10640	}
10641	out.Dispatch()
10642	if invalids > 0 {
10643		return graphql.Null
10644	}
10645	return out
10646}
10647
10648var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
10649
10650func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
10651	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
10652
10653	out := graphql.NewFieldSet(fields)
10654	var invalids uint32
10655	for i, field := range fields {
10656		switch field.Name {
10657		case "__typename":
10658			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
10659		case "clientMutationId":
10660			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
10661		case "bug":
10662			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
10663			if out.Values[i] == graphql.Null {
10664				invalids++
10665			}
10666		case "operation":
10667			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
10668			if out.Values[i] == graphql.Null {
10669				invalids++
10670			}
10671		case "results":
10672			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
10673			if out.Values[i] == graphql.Null {
10674				invalids++
10675			}
10676		default:
10677			panic("unknown field " + strconv.Quote(field.Name))
10678		}
10679	}
10680	out.Dispatch()
10681	if invalids > 0 {
10682		return graphql.Null
10683	}
10684	return out
10685}
10686
10687var closeBugPayloadImplementors = []string{"CloseBugPayload"}
10688
10689func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
10690	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
10691
10692	out := graphql.NewFieldSet(fields)
10693	var invalids uint32
10694	for i, field := range fields {
10695		switch field.Name {
10696		case "__typename":
10697			out.Values[i] = graphql.MarshalString("CloseBugPayload")
10698		case "clientMutationId":
10699			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
10700		case "bug":
10701			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
10702			if out.Values[i] == graphql.Null {
10703				invalids++
10704			}
10705		case "operation":
10706			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
10707			if out.Values[i] == graphql.Null {
10708				invalids++
10709			}
10710		default:
10711			panic("unknown field " + strconv.Quote(field.Name))
10712		}
10713	}
10714	out.Dispatch()
10715	if invalids > 0 {
10716		return graphql.Null
10717	}
10718	return out
10719}
10720
10721var colorImplementors = []string{"Color"}
10722
10723func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
10724	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
10725
10726	out := graphql.NewFieldSet(fields)
10727	var invalids uint32
10728	for i, field := range fields {
10729		switch field.Name {
10730		case "__typename":
10731			out.Values[i] = graphql.MarshalString("Color")
10732		case "R":
10733			field := field
10734			out.Concurrently(i, func() (res graphql.Marshaler) {
10735				defer func() {
10736					if r := recover(); r != nil {
10737						ec.Error(ctx, ec.Recover(ctx, r))
10738					}
10739				}()
10740				res = ec._Color_R(ctx, field, obj)
10741				if res == graphql.Null {
10742					atomic.AddUint32(&invalids, 1)
10743				}
10744				return res
10745			})
10746		case "G":
10747			field := field
10748			out.Concurrently(i, func() (res graphql.Marshaler) {
10749				defer func() {
10750					if r := recover(); r != nil {
10751						ec.Error(ctx, ec.Recover(ctx, r))
10752					}
10753				}()
10754				res = ec._Color_G(ctx, field, obj)
10755				if res == graphql.Null {
10756					atomic.AddUint32(&invalids, 1)
10757				}
10758				return res
10759			})
10760		case "B":
10761			field := field
10762			out.Concurrently(i, func() (res graphql.Marshaler) {
10763				defer func() {
10764					if r := recover(); r != nil {
10765						ec.Error(ctx, ec.Recover(ctx, r))
10766					}
10767				}()
10768				res = ec._Color_B(ctx, field, obj)
10769				if res == graphql.Null {
10770					atomic.AddUint32(&invalids, 1)
10771				}
10772				return res
10773			})
10774		default:
10775			panic("unknown field " + strconv.Quote(field.Name))
10776		}
10777	}
10778	out.Dispatch()
10779	if invalids > 0 {
10780		return graphql.Null
10781	}
10782	return out
10783}
10784
10785var commentImplementors = []string{"Comment", "Authored"}
10786
10787func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
10788	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
10789
10790	out := graphql.NewFieldSet(fields)
10791	var invalids uint32
10792	for i, field := range fields {
10793		switch field.Name {
10794		case "__typename":
10795			out.Values[i] = graphql.MarshalString("Comment")
10796		case "author":
10797			field := field
10798			out.Concurrently(i, func() (res graphql.Marshaler) {
10799				defer func() {
10800					if r := recover(); r != nil {
10801						ec.Error(ctx, ec.Recover(ctx, r))
10802					}
10803				}()
10804				res = ec._Comment_author(ctx, field, obj)
10805				if res == graphql.Null {
10806					atomic.AddUint32(&invalids, 1)
10807				}
10808				return res
10809			})
10810		case "message":
10811			out.Values[i] = ec._Comment_message(ctx, field, obj)
10812			if out.Values[i] == graphql.Null {
10813				atomic.AddUint32(&invalids, 1)
10814			}
10815		case "files":
10816			out.Values[i] = ec._Comment_files(ctx, field, obj)
10817			if out.Values[i] == graphql.Null {
10818				atomic.AddUint32(&invalids, 1)
10819			}
10820		default:
10821			panic("unknown field " + strconv.Quote(field.Name))
10822		}
10823	}
10824	out.Dispatch()
10825	if invalids > 0 {
10826		return graphql.Null
10827	}
10828	return out
10829}
10830
10831var commentConnectionImplementors = []string{"CommentConnection"}
10832
10833func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
10834	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
10835
10836	out := graphql.NewFieldSet(fields)
10837	var invalids uint32
10838	for i, field := range fields {
10839		switch field.Name {
10840		case "__typename":
10841			out.Values[i] = graphql.MarshalString("CommentConnection")
10842		case "edges":
10843			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
10844			if out.Values[i] == graphql.Null {
10845				invalids++
10846			}
10847		case "nodes":
10848			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
10849			if out.Values[i] == graphql.Null {
10850				invalids++
10851			}
10852		case "pageInfo":
10853			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
10854			if out.Values[i] == graphql.Null {
10855				invalids++
10856			}
10857		case "totalCount":
10858			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
10859			if out.Values[i] == graphql.Null {
10860				invalids++
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 commentEdgeImplementors = []string{"CommentEdge"}
10874
10875func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
10876	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
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("CommentEdge")
10884		case "cursor":
10885			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
10886			if out.Values[i] == graphql.Null {
10887				invalids++
10888			}
10889		case "node":
10890			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
10891			if out.Values[i] == graphql.Null {
10892				invalids++
10893			}
10894		default:
10895			panic("unknown field " + strconv.Quote(field.Name))
10896		}
10897	}
10898	out.Dispatch()
10899	if invalids > 0 {
10900		return graphql.Null
10901	}
10902	return out
10903}
10904
10905var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
10906
10907func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
10908	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
10909
10910	out := graphql.NewFieldSet(fields)
10911	var invalids uint32
10912	for i, field := range fields {
10913		switch field.Name {
10914		case "__typename":
10915			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
10916		case "message":
10917			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
10918			if out.Values[i] == graphql.Null {
10919				atomic.AddUint32(&invalids, 1)
10920			}
10921		case "date":
10922			field := field
10923			out.Concurrently(i, func() (res graphql.Marshaler) {
10924				defer func() {
10925					if r := recover(); r != nil {
10926						ec.Error(ctx, ec.Recover(ctx, r))
10927					}
10928				}()
10929				res = ec._CommentHistoryStep_date(ctx, field, obj)
10930				if res == graphql.Null {
10931					atomic.AddUint32(&invalids, 1)
10932				}
10933				return res
10934			})
10935		default:
10936			panic("unknown field " + strconv.Quote(field.Name))
10937		}
10938	}
10939	out.Dispatch()
10940	if invalids > 0 {
10941		return graphql.Null
10942	}
10943	return out
10944}
10945
10946var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
10947
10948func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
10949	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
10950
10951	out := graphql.NewFieldSet(fields)
10952	var invalids uint32
10953	for i, field := range fields {
10954		switch field.Name {
10955		case "__typename":
10956			out.Values[i] = graphql.MarshalString("CreateOperation")
10957		case "id":
10958			field := field
10959			out.Concurrently(i, func() (res graphql.Marshaler) {
10960				defer func() {
10961					if r := recover(); r != nil {
10962						ec.Error(ctx, ec.Recover(ctx, r))
10963					}
10964				}()
10965				res = ec._CreateOperation_id(ctx, field, obj)
10966				if res == graphql.Null {
10967					atomic.AddUint32(&invalids, 1)
10968				}
10969				return res
10970			})
10971		case "author":
10972			field := field
10973			out.Concurrently(i, func() (res graphql.Marshaler) {
10974				defer func() {
10975					if r := recover(); r != nil {
10976						ec.Error(ctx, ec.Recover(ctx, r))
10977					}
10978				}()
10979				res = ec._CreateOperation_author(ctx, field, obj)
10980				if res == graphql.Null {
10981					atomic.AddUint32(&invalids, 1)
10982				}
10983				return res
10984			})
10985		case "date":
10986			field := field
10987			out.Concurrently(i, func() (res graphql.Marshaler) {
10988				defer func() {
10989					if r := recover(); r != nil {
10990						ec.Error(ctx, ec.Recover(ctx, r))
10991					}
10992				}()
10993				res = ec._CreateOperation_date(ctx, field, obj)
10994				if res == graphql.Null {
10995					atomic.AddUint32(&invalids, 1)
10996				}
10997				return res
10998			})
10999		case "title":
11000			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11001			if out.Values[i] == graphql.Null {
11002				atomic.AddUint32(&invalids, 1)
11003			}
11004		case "message":
11005			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11006			if out.Values[i] == graphql.Null {
11007				atomic.AddUint32(&invalids, 1)
11008			}
11009		case "files":
11010			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11011			if out.Values[i] == graphql.Null {
11012				atomic.AddUint32(&invalids, 1)
11013			}
11014		default:
11015			panic("unknown field " + strconv.Quote(field.Name))
11016		}
11017	}
11018	out.Dispatch()
11019	if invalids > 0 {
11020		return graphql.Null
11021	}
11022	return out
11023}
11024
11025var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11026
11027func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11028	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11029
11030	out := graphql.NewFieldSet(fields)
11031	var invalids uint32
11032	for i, field := range fields {
11033		switch field.Name {
11034		case "__typename":
11035			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11036		case "id":
11037			field := field
11038			out.Concurrently(i, func() (res graphql.Marshaler) {
11039				defer func() {
11040					if r := recover(); r != nil {
11041						ec.Error(ctx, ec.Recover(ctx, r))
11042					}
11043				}()
11044				res = ec._CreateTimelineItem_id(ctx, field, obj)
11045				if res == graphql.Null {
11046					atomic.AddUint32(&invalids, 1)
11047				}
11048				return res
11049			})
11050		case "author":
11051			field := field
11052			out.Concurrently(i, func() (res graphql.Marshaler) {
11053				defer func() {
11054					if r := recover(); r != nil {
11055						ec.Error(ctx, ec.Recover(ctx, r))
11056					}
11057				}()
11058				res = ec._CreateTimelineItem_author(ctx, field, obj)
11059				if res == graphql.Null {
11060					atomic.AddUint32(&invalids, 1)
11061				}
11062				return res
11063			})
11064		case "message":
11065			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11066			if out.Values[i] == graphql.Null {
11067				atomic.AddUint32(&invalids, 1)
11068			}
11069		case "messageIsEmpty":
11070			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11071			if out.Values[i] == graphql.Null {
11072				atomic.AddUint32(&invalids, 1)
11073			}
11074		case "files":
11075			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11076			if out.Values[i] == graphql.Null {
11077				atomic.AddUint32(&invalids, 1)
11078			}
11079		case "createdAt":
11080			field := field
11081			out.Concurrently(i, func() (res graphql.Marshaler) {
11082				defer func() {
11083					if r := recover(); r != nil {
11084						ec.Error(ctx, ec.Recover(ctx, r))
11085					}
11086				}()
11087				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11088				if res == graphql.Null {
11089					atomic.AddUint32(&invalids, 1)
11090				}
11091				return res
11092			})
11093		case "lastEdit":
11094			field := field
11095			out.Concurrently(i, func() (res graphql.Marshaler) {
11096				defer func() {
11097					if r := recover(); r != nil {
11098						ec.Error(ctx, ec.Recover(ctx, r))
11099					}
11100				}()
11101				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11102				if res == graphql.Null {
11103					atomic.AddUint32(&invalids, 1)
11104				}
11105				return res
11106			})
11107		case "edited":
11108			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11109			if out.Values[i] == graphql.Null {
11110				atomic.AddUint32(&invalids, 1)
11111			}
11112		case "history":
11113			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11114			if out.Values[i] == graphql.Null {
11115				atomic.AddUint32(&invalids, 1)
11116			}
11117		default:
11118			panic("unknown field " + strconv.Quote(field.Name))
11119		}
11120	}
11121	out.Dispatch()
11122	if invalids > 0 {
11123		return graphql.Null
11124	}
11125	return out
11126}
11127
11128var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11129
11130func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11131	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11132
11133	out := graphql.NewFieldSet(fields)
11134	var invalids uint32
11135	for i, field := range fields {
11136		switch field.Name {
11137		case "__typename":
11138			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11139		case "id":
11140			field := field
11141			out.Concurrently(i, func() (res graphql.Marshaler) {
11142				defer func() {
11143					if r := recover(); r != nil {
11144						ec.Error(ctx, ec.Recover(ctx, r))
11145					}
11146				}()
11147				res = ec._EditCommentOperation_id(ctx, field, obj)
11148				if res == graphql.Null {
11149					atomic.AddUint32(&invalids, 1)
11150				}
11151				return res
11152			})
11153		case "author":
11154			field := field
11155			out.Concurrently(i, func() (res graphql.Marshaler) {
11156				defer func() {
11157					if r := recover(); r != nil {
11158						ec.Error(ctx, ec.Recover(ctx, r))
11159					}
11160				}()
11161				res = ec._EditCommentOperation_author(ctx, field, obj)
11162				if res == graphql.Null {
11163					atomic.AddUint32(&invalids, 1)
11164				}
11165				return res
11166			})
11167		case "date":
11168			field := field
11169			out.Concurrently(i, func() (res graphql.Marshaler) {
11170				defer func() {
11171					if r := recover(); r != nil {
11172						ec.Error(ctx, ec.Recover(ctx, r))
11173					}
11174				}()
11175				res = ec._EditCommentOperation_date(ctx, field, obj)
11176				if res == graphql.Null {
11177					atomic.AddUint32(&invalids, 1)
11178				}
11179				return res
11180			})
11181		case "target":
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_target(ctx, field, obj)
11190				if res == graphql.Null {
11191					atomic.AddUint32(&invalids, 1)
11192				}
11193				return res
11194			})
11195		case "message":
11196			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11197			if out.Values[i] == graphql.Null {
11198				atomic.AddUint32(&invalids, 1)
11199			}
11200		case "files":
11201			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11202			if out.Values[i] == graphql.Null {
11203				atomic.AddUint32(&invalids, 1)
11204			}
11205		default:
11206			panic("unknown field " + strconv.Quote(field.Name))
11207		}
11208	}
11209	out.Dispatch()
11210	if invalids > 0 {
11211		return graphql.Null
11212	}
11213	return out
11214}
11215
11216var identityImplementors = []string{"Identity"}
11217
11218func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11219	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11220
11221	out := graphql.NewFieldSet(fields)
11222	var invalids uint32
11223	for i, field := range fields {
11224		switch field.Name {
11225		case "__typename":
11226			out.Values[i] = graphql.MarshalString("Identity")
11227		case "id":
11228			field := field
11229			out.Concurrently(i, func() (res graphql.Marshaler) {
11230				defer func() {
11231					if r := recover(); r != nil {
11232						ec.Error(ctx, ec.Recover(ctx, r))
11233					}
11234				}()
11235				res = ec._Identity_id(ctx, field, obj)
11236				if res == graphql.Null {
11237					atomic.AddUint32(&invalids, 1)
11238				}
11239				return res
11240			})
11241		case "humanId":
11242			field := field
11243			out.Concurrently(i, func() (res graphql.Marshaler) {
11244				defer func() {
11245					if r := recover(); r != nil {
11246						ec.Error(ctx, ec.Recover(ctx, r))
11247					}
11248				}()
11249				res = ec._Identity_humanId(ctx, field, obj)
11250				if res == graphql.Null {
11251					atomic.AddUint32(&invalids, 1)
11252				}
11253				return res
11254			})
11255		case "name":
11256			out.Values[i] = ec._Identity_name(ctx, field, obj)
11257		case "email":
11258			out.Values[i] = ec._Identity_email(ctx, field, obj)
11259		case "displayName":
11260			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11261			if out.Values[i] == graphql.Null {
11262				atomic.AddUint32(&invalids, 1)
11263			}
11264		case "avatarUrl":
11265			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11266		case "isProtected":
11267			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11268			if out.Values[i] == graphql.Null {
11269				atomic.AddUint32(&invalids, 1)
11270			}
11271		default:
11272			panic("unknown field " + strconv.Quote(field.Name))
11273		}
11274	}
11275	out.Dispatch()
11276	if invalids > 0 {
11277		return graphql.Null
11278	}
11279	return out
11280}
11281
11282var identityConnectionImplementors = []string{"IdentityConnection"}
11283
11284func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11285	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11286
11287	out := graphql.NewFieldSet(fields)
11288	var invalids uint32
11289	for i, field := range fields {
11290		switch field.Name {
11291		case "__typename":
11292			out.Values[i] = graphql.MarshalString("IdentityConnection")
11293		case "edges":
11294			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11295			if out.Values[i] == graphql.Null {
11296				invalids++
11297			}
11298		case "nodes":
11299			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11300			if out.Values[i] == graphql.Null {
11301				invalids++
11302			}
11303		case "pageInfo":
11304			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11305			if out.Values[i] == graphql.Null {
11306				invalids++
11307			}
11308		case "totalCount":
11309			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11310			if out.Values[i] == graphql.Null {
11311				invalids++
11312			}
11313		default:
11314			panic("unknown field " + strconv.Quote(field.Name))
11315		}
11316	}
11317	out.Dispatch()
11318	if invalids > 0 {
11319		return graphql.Null
11320	}
11321	return out
11322}
11323
11324var identityEdgeImplementors = []string{"IdentityEdge"}
11325
11326func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11327	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11328
11329	out := graphql.NewFieldSet(fields)
11330	var invalids uint32
11331	for i, field := range fields {
11332		switch field.Name {
11333		case "__typename":
11334			out.Values[i] = graphql.MarshalString("IdentityEdge")
11335		case "cursor":
11336			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11337			if out.Values[i] == graphql.Null {
11338				invalids++
11339			}
11340		case "node":
11341			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11342			if out.Values[i] == graphql.Null {
11343				invalids++
11344			}
11345		default:
11346			panic("unknown field " + strconv.Quote(field.Name))
11347		}
11348	}
11349	out.Dispatch()
11350	if invalids > 0 {
11351		return graphql.Null
11352	}
11353	return out
11354}
11355
11356var labelImplementors = []string{"Label"}
11357
11358func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11359	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11360
11361	out := graphql.NewFieldSet(fields)
11362	var invalids uint32
11363	for i, field := range fields {
11364		switch field.Name {
11365		case "__typename":
11366			out.Values[i] = graphql.MarshalString("Label")
11367		case "name":
11368			field := field
11369			out.Concurrently(i, func() (res graphql.Marshaler) {
11370				defer func() {
11371					if r := recover(); r != nil {
11372						ec.Error(ctx, ec.Recover(ctx, r))
11373					}
11374				}()
11375				res = ec._Label_name(ctx, field, obj)
11376				if res == graphql.Null {
11377					atomic.AddUint32(&invalids, 1)
11378				}
11379				return res
11380			})
11381		case "color":
11382			field := field
11383			out.Concurrently(i, func() (res graphql.Marshaler) {
11384				defer func() {
11385					if r := recover(); r != nil {
11386						ec.Error(ctx, ec.Recover(ctx, r))
11387					}
11388				}()
11389				res = ec._Label_color(ctx, field, obj)
11390				if res == graphql.Null {
11391					atomic.AddUint32(&invalids, 1)
11392				}
11393				return res
11394			})
11395		default:
11396			panic("unknown field " + strconv.Quote(field.Name))
11397		}
11398	}
11399	out.Dispatch()
11400	if invalids > 0 {
11401		return graphql.Null
11402	}
11403	return out
11404}
11405
11406var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11407
11408func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11409	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11410
11411	out := graphql.NewFieldSet(fields)
11412	var invalids uint32
11413	for i, field := range fields {
11414		switch field.Name {
11415		case "__typename":
11416			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11417		case "id":
11418			field := field
11419			out.Concurrently(i, func() (res graphql.Marshaler) {
11420				defer func() {
11421					if r := recover(); r != nil {
11422						ec.Error(ctx, ec.Recover(ctx, r))
11423					}
11424				}()
11425				res = ec._LabelChangeOperation_id(ctx, field, obj)
11426				if res == graphql.Null {
11427					atomic.AddUint32(&invalids, 1)
11428				}
11429				return res
11430			})
11431		case "author":
11432			field := field
11433			out.Concurrently(i, func() (res graphql.Marshaler) {
11434				defer func() {
11435					if r := recover(); r != nil {
11436						ec.Error(ctx, ec.Recover(ctx, r))
11437					}
11438				}()
11439				res = ec._LabelChangeOperation_author(ctx, field, obj)
11440				if res == graphql.Null {
11441					atomic.AddUint32(&invalids, 1)
11442				}
11443				return res
11444			})
11445		case "date":
11446			field := field
11447			out.Concurrently(i, func() (res graphql.Marshaler) {
11448				defer func() {
11449					if r := recover(); r != nil {
11450						ec.Error(ctx, ec.Recover(ctx, r))
11451					}
11452				}()
11453				res = ec._LabelChangeOperation_date(ctx, field, obj)
11454				if res == graphql.Null {
11455					atomic.AddUint32(&invalids, 1)
11456				}
11457				return res
11458			})
11459		case "added":
11460			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11461			if out.Values[i] == graphql.Null {
11462				atomic.AddUint32(&invalids, 1)
11463			}
11464		case "removed":
11465			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11466			if out.Values[i] == graphql.Null {
11467				atomic.AddUint32(&invalids, 1)
11468			}
11469		default:
11470			panic("unknown field " + strconv.Quote(field.Name))
11471		}
11472	}
11473	out.Dispatch()
11474	if invalids > 0 {
11475		return graphql.Null
11476	}
11477	return out
11478}
11479
11480var labelChangeResultImplementors = []string{"LabelChangeResult"}
11481
11482func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11483	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11484
11485	out := graphql.NewFieldSet(fields)
11486	var invalids uint32
11487	for i, field := range fields {
11488		switch field.Name {
11489		case "__typename":
11490			out.Values[i] = graphql.MarshalString("LabelChangeResult")
11491		case "label":
11492			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11493			if out.Values[i] == graphql.Null {
11494				atomic.AddUint32(&invalids, 1)
11495			}
11496		case "status":
11497			field := field
11498			out.Concurrently(i, func() (res graphql.Marshaler) {
11499				defer func() {
11500					if r := recover(); r != nil {
11501						ec.Error(ctx, ec.Recover(ctx, r))
11502					}
11503				}()
11504				res = ec._LabelChangeResult_status(ctx, field, obj)
11505				if res == graphql.Null {
11506					atomic.AddUint32(&invalids, 1)
11507				}
11508				return res
11509			})
11510		default:
11511			panic("unknown field " + strconv.Quote(field.Name))
11512		}
11513	}
11514	out.Dispatch()
11515	if invalids > 0 {
11516		return graphql.Null
11517	}
11518	return out
11519}
11520
11521var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11522
11523func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11524	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11525
11526	out := graphql.NewFieldSet(fields)
11527	var invalids uint32
11528	for i, field := range fields {
11529		switch field.Name {
11530		case "__typename":
11531			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11532		case "id":
11533			field := field
11534			out.Concurrently(i, func() (res graphql.Marshaler) {
11535				defer func() {
11536					if r := recover(); r != nil {
11537						ec.Error(ctx, ec.Recover(ctx, r))
11538					}
11539				}()
11540				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11541				if res == graphql.Null {
11542					atomic.AddUint32(&invalids, 1)
11543				}
11544				return res
11545			})
11546		case "author":
11547			field := field
11548			out.Concurrently(i, func() (res graphql.Marshaler) {
11549				defer func() {
11550					if r := recover(); r != nil {
11551						ec.Error(ctx, ec.Recover(ctx, r))
11552					}
11553				}()
11554				res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
11555				if res == graphql.Null {
11556					atomic.AddUint32(&invalids, 1)
11557				}
11558				return res
11559			})
11560		case "date":
11561			field := field
11562			out.Concurrently(i, func() (res graphql.Marshaler) {
11563				defer func() {
11564					if r := recover(); r != nil {
11565						ec.Error(ctx, ec.Recover(ctx, r))
11566					}
11567				}()
11568				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
11569				if res == graphql.Null {
11570					atomic.AddUint32(&invalids, 1)
11571				}
11572				return res
11573			})
11574		case "added":
11575			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
11576			if out.Values[i] == graphql.Null {
11577				atomic.AddUint32(&invalids, 1)
11578			}
11579		case "removed":
11580			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
11581			if out.Values[i] == graphql.Null {
11582				atomic.AddUint32(&invalids, 1)
11583			}
11584		default:
11585			panic("unknown field " + strconv.Quote(field.Name))
11586		}
11587	}
11588	out.Dispatch()
11589	if invalids > 0 {
11590		return graphql.Null
11591	}
11592	return out
11593}
11594
11595var labelConnectionImplementors = []string{"LabelConnection"}
11596
11597func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
11598	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
11599
11600	out := graphql.NewFieldSet(fields)
11601	var invalids uint32
11602	for i, field := range fields {
11603		switch field.Name {
11604		case "__typename":
11605			out.Values[i] = graphql.MarshalString("LabelConnection")
11606		case "edges":
11607			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
11608			if out.Values[i] == graphql.Null {
11609				invalids++
11610			}
11611		case "nodes":
11612			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
11613			if out.Values[i] == graphql.Null {
11614				invalids++
11615			}
11616		case "pageInfo":
11617			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
11618			if out.Values[i] == graphql.Null {
11619				invalids++
11620			}
11621		case "totalCount":
11622			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
11623			if out.Values[i] == graphql.Null {
11624				invalids++
11625			}
11626		default:
11627			panic("unknown field " + strconv.Quote(field.Name))
11628		}
11629	}
11630	out.Dispatch()
11631	if invalids > 0 {
11632		return graphql.Null
11633	}
11634	return out
11635}
11636
11637var labelEdgeImplementors = []string{"LabelEdge"}
11638
11639func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
11640	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
11641
11642	out := graphql.NewFieldSet(fields)
11643	var invalids uint32
11644	for i, field := range fields {
11645		switch field.Name {
11646		case "__typename":
11647			out.Values[i] = graphql.MarshalString("LabelEdge")
11648		case "cursor":
11649			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
11650			if out.Values[i] == graphql.Null {
11651				invalids++
11652			}
11653		case "node":
11654			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
11655			if out.Values[i] == graphql.Null {
11656				invalids++
11657			}
11658		default:
11659			panic("unknown field " + strconv.Quote(field.Name))
11660		}
11661	}
11662	out.Dispatch()
11663	if invalids > 0 {
11664		return graphql.Null
11665	}
11666	return out
11667}
11668
11669var mutationImplementors = []string{"Mutation"}
11670
11671func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11672	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
11673
11674	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11675		Object: "Mutation",
11676	})
11677
11678	out := graphql.NewFieldSet(fields)
11679	var invalids uint32
11680	for i, field := range fields {
11681		switch field.Name {
11682		case "__typename":
11683			out.Values[i] = graphql.MarshalString("Mutation")
11684		case "newBug":
11685			out.Values[i] = ec._Mutation_newBug(ctx, field)
11686			if out.Values[i] == graphql.Null {
11687				invalids++
11688			}
11689		case "addComment":
11690			out.Values[i] = ec._Mutation_addComment(ctx, field)
11691			if out.Values[i] == graphql.Null {
11692				invalids++
11693			}
11694		case "changeLabels":
11695			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
11696			if out.Values[i] == graphql.Null {
11697				invalids++
11698			}
11699		case "openBug":
11700			out.Values[i] = ec._Mutation_openBug(ctx, field)
11701			if out.Values[i] == graphql.Null {
11702				invalids++
11703			}
11704		case "closeBug":
11705			out.Values[i] = ec._Mutation_closeBug(ctx, field)
11706			if out.Values[i] == graphql.Null {
11707				invalids++
11708			}
11709		case "setTitle":
11710			out.Values[i] = ec._Mutation_setTitle(ctx, field)
11711			if out.Values[i] == graphql.Null {
11712				invalids++
11713			}
11714		default:
11715			panic("unknown field " + strconv.Quote(field.Name))
11716		}
11717	}
11718	out.Dispatch()
11719	if invalids > 0 {
11720		return graphql.Null
11721	}
11722	return out
11723}
11724
11725var newBugPayloadImplementors = []string{"NewBugPayload"}
11726
11727func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
11728	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
11729
11730	out := graphql.NewFieldSet(fields)
11731	var invalids uint32
11732	for i, field := range fields {
11733		switch field.Name {
11734		case "__typename":
11735			out.Values[i] = graphql.MarshalString("NewBugPayload")
11736		case "clientMutationId":
11737			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
11738		case "bug":
11739			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
11740			if out.Values[i] == graphql.Null {
11741				invalids++
11742			}
11743		case "operation":
11744			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
11745			if out.Values[i] == graphql.Null {
11746				invalids++
11747			}
11748		default:
11749			panic("unknown field " + strconv.Quote(field.Name))
11750		}
11751	}
11752	out.Dispatch()
11753	if invalids > 0 {
11754		return graphql.Null
11755	}
11756	return out
11757}
11758
11759var openBugPayloadImplementors = []string{"OpenBugPayload"}
11760
11761func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
11762	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
11763
11764	out := graphql.NewFieldSet(fields)
11765	var invalids uint32
11766	for i, field := range fields {
11767		switch field.Name {
11768		case "__typename":
11769			out.Values[i] = graphql.MarshalString("OpenBugPayload")
11770		case "clientMutationId":
11771			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
11772		case "bug":
11773			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
11774			if out.Values[i] == graphql.Null {
11775				invalids++
11776			}
11777		case "operation":
11778			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
11779			if out.Values[i] == graphql.Null {
11780				invalids++
11781			}
11782		default:
11783			panic("unknown field " + strconv.Quote(field.Name))
11784		}
11785	}
11786	out.Dispatch()
11787	if invalids > 0 {
11788		return graphql.Null
11789	}
11790	return out
11791}
11792
11793var operationConnectionImplementors = []string{"OperationConnection"}
11794
11795func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
11796	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
11797
11798	out := graphql.NewFieldSet(fields)
11799	var invalids uint32
11800	for i, field := range fields {
11801		switch field.Name {
11802		case "__typename":
11803			out.Values[i] = graphql.MarshalString("OperationConnection")
11804		case "edges":
11805			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
11806			if out.Values[i] == graphql.Null {
11807				invalids++
11808			}
11809		case "nodes":
11810			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
11811			if out.Values[i] == graphql.Null {
11812				invalids++
11813			}
11814		case "pageInfo":
11815			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
11816			if out.Values[i] == graphql.Null {
11817				invalids++
11818			}
11819		case "totalCount":
11820			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
11821			if out.Values[i] == graphql.Null {
11822				invalids++
11823			}
11824		default:
11825			panic("unknown field " + strconv.Quote(field.Name))
11826		}
11827	}
11828	out.Dispatch()
11829	if invalids > 0 {
11830		return graphql.Null
11831	}
11832	return out
11833}
11834
11835var operationEdgeImplementors = []string{"OperationEdge"}
11836
11837func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
11838	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
11839
11840	out := graphql.NewFieldSet(fields)
11841	var invalids uint32
11842	for i, field := range fields {
11843		switch field.Name {
11844		case "__typename":
11845			out.Values[i] = graphql.MarshalString("OperationEdge")
11846		case "cursor":
11847			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
11848			if out.Values[i] == graphql.Null {
11849				invalids++
11850			}
11851		case "node":
11852			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
11853			if out.Values[i] == graphql.Null {
11854				invalids++
11855			}
11856		default:
11857			panic("unknown field " + strconv.Quote(field.Name))
11858		}
11859	}
11860	out.Dispatch()
11861	if invalids > 0 {
11862		return graphql.Null
11863	}
11864	return out
11865}
11866
11867var pageInfoImplementors = []string{"PageInfo"}
11868
11869func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
11870	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
11871
11872	out := graphql.NewFieldSet(fields)
11873	var invalids uint32
11874	for i, field := range fields {
11875		switch field.Name {
11876		case "__typename":
11877			out.Values[i] = graphql.MarshalString("PageInfo")
11878		case "hasNextPage":
11879			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
11880			if out.Values[i] == graphql.Null {
11881				invalids++
11882			}
11883		case "hasPreviousPage":
11884			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
11885			if out.Values[i] == graphql.Null {
11886				invalids++
11887			}
11888		case "startCursor":
11889			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
11890			if out.Values[i] == graphql.Null {
11891				invalids++
11892			}
11893		case "endCursor":
11894			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
11895			if out.Values[i] == graphql.Null {
11896				invalids++
11897			}
11898		default:
11899			panic("unknown field " + strconv.Quote(field.Name))
11900		}
11901	}
11902	out.Dispatch()
11903	if invalids > 0 {
11904		return graphql.Null
11905	}
11906	return out
11907}
11908
11909var queryImplementors = []string{"Query"}
11910
11911func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
11912	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
11913
11914	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
11915		Object: "Query",
11916	})
11917
11918	out := graphql.NewFieldSet(fields)
11919	var invalids uint32
11920	for i, field := range fields {
11921		switch field.Name {
11922		case "__typename":
11923			out.Values[i] = graphql.MarshalString("Query")
11924		case "repository":
11925			field := field
11926			out.Concurrently(i, func() (res graphql.Marshaler) {
11927				defer func() {
11928					if r := recover(); r != nil {
11929						ec.Error(ctx, ec.Recover(ctx, r))
11930					}
11931				}()
11932				res = ec._Query_repository(ctx, field)
11933				return res
11934			})
11935		case "__type":
11936			out.Values[i] = ec._Query___type(ctx, field)
11937		case "__schema":
11938			out.Values[i] = ec._Query___schema(ctx, field)
11939		default:
11940			panic("unknown field " + strconv.Quote(field.Name))
11941		}
11942	}
11943	out.Dispatch()
11944	if invalids > 0 {
11945		return graphql.Null
11946	}
11947	return out
11948}
11949
11950var repositoryImplementors = []string{"Repository"}
11951
11952func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
11953	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
11954
11955	out := graphql.NewFieldSet(fields)
11956	var invalids uint32
11957	for i, field := range fields {
11958		switch field.Name {
11959		case "__typename":
11960			out.Values[i] = graphql.MarshalString("Repository")
11961		case "name":
11962			field := field
11963			out.Concurrently(i, func() (res graphql.Marshaler) {
11964				defer func() {
11965					if r := recover(); r != nil {
11966						ec.Error(ctx, ec.Recover(ctx, r))
11967					}
11968				}()
11969				res = ec._Repository_name(ctx, field, obj)
11970				return res
11971			})
11972		case "allBugs":
11973			field := field
11974			out.Concurrently(i, func() (res graphql.Marshaler) {
11975				defer func() {
11976					if r := recover(); r != nil {
11977						ec.Error(ctx, ec.Recover(ctx, r))
11978					}
11979				}()
11980				res = ec._Repository_allBugs(ctx, field, obj)
11981				if res == graphql.Null {
11982					atomic.AddUint32(&invalids, 1)
11983				}
11984				return res
11985			})
11986		case "bug":
11987			field := field
11988			out.Concurrently(i, func() (res graphql.Marshaler) {
11989				defer func() {
11990					if r := recover(); r != nil {
11991						ec.Error(ctx, ec.Recover(ctx, r))
11992					}
11993				}()
11994				res = ec._Repository_bug(ctx, field, obj)
11995				return res
11996			})
11997		case "allIdentities":
11998			field := field
11999			out.Concurrently(i, func() (res graphql.Marshaler) {
12000				defer func() {
12001					if r := recover(); r != nil {
12002						ec.Error(ctx, ec.Recover(ctx, r))
12003					}
12004				}()
12005				res = ec._Repository_allIdentities(ctx, field, obj)
12006				if res == graphql.Null {
12007					atomic.AddUint32(&invalids, 1)
12008				}
12009				return res
12010			})
12011		case "identity":
12012			field := field
12013			out.Concurrently(i, func() (res graphql.Marshaler) {
12014				defer func() {
12015					if r := recover(); r != nil {
12016						ec.Error(ctx, ec.Recover(ctx, r))
12017					}
12018				}()
12019				res = ec._Repository_identity(ctx, field, obj)
12020				return res
12021			})
12022		case "userIdentity":
12023			field := field
12024			out.Concurrently(i, func() (res graphql.Marshaler) {
12025				defer func() {
12026					if r := recover(); r != nil {
12027						ec.Error(ctx, ec.Recover(ctx, r))
12028					}
12029				}()
12030				res = ec._Repository_userIdentity(ctx, field, obj)
12031				return res
12032			})
12033		case "validLabels":
12034			field := field
12035			out.Concurrently(i, func() (res graphql.Marshaler) {
12036				defer func() {
12037					if r := recover(); r != nil {
12038						ec.Error(ctx, ec.Recover(ctx, r))
12039					}
12040				}()
12041				res = ec._Repository_validLabels(ctx, field, obj)
12042				if res == graphql.Null {
12043					atomic.AddUint32(&invalids, 1)
12044				}
12045				return res
12046			})
12047		default:
12048			panic("unknown field " + strconv.Quote(field.Name))
12049		}
12050	}
12051	out.Dispatch()
12052	if invalids > 0 {
12053		return graphql.Null
12054	}
12055	return out
12056}
12057
12058var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12059
12060func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12061	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12062
12063	out := graphql.NewFieldSet(fields)
12064	var invalids uint32
12065	for i, field := range fields {
12066		switch field.Name {
12067		case "__typename":
12068			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12069		case "id":
12070			field := field
12071			out.Concurrently(i, func() (res graphql.Marshaler) {
12072				defer func() {
12073					if r := recover(); r != nil {
12074						ec.Error(ctx, ec.Recover(ctx, r))
12075					}
12076				}()
12077				res = ec._SetStatusOperation_id(ctx, field, obj)
12078				if res == graphql.Null {
12079					atomic.AddUint32(&invalids, 1)
12080				}
12081				return res
12082			})
12083		case "author":
12084			field := field
12085			out.Concurrently(i, func() (res graphql.Marshaler) {
12086				defer func() {
12087					if r := recover(); r != nil {
12088						ec.Error(ctx, ec.Recover(ctx, r))
12089					}
12090				}()
12091				res = ec._SetStatusOperation_author(ctx, field, obj)
12092				if res == graphql.Null {
12093					atomic.AddUint32(&invalids, 1)
12094				}
12095				return res
12096			})
12097		case "date":
12098			field := field
12099			out.Concurrently(i, func() (res graphql.Marshaler) {
12100				defer func() {
12101					if r := recover(); r != nil {
12102						ec.Error(ctx, ec.Recover(ctx, r))
12103					}
12104				}()
12105				res = ec._SetStatusOperation_date(ctx, field, obj)
12106				if res == graphql.Null {
12107					atomic.AddUint32(&invalids, 1)
12108				}
12109				return res
12110			})
12111		case "status":
12112			field := field
12113			out.Concurrently(i, func() (res graphql.Marshaler) {
12114				defer func() {
12115					if r := recover(); r != nil {
12116						ec.Error(ctx, ec.Recover(ctx, r))
12117					}
12118				}()
12119				res = ec._SetStatusOperation_status(ctx, field, obj)
12120				if res == graphql.Null {
12121					atomic.AddUint32(&invalids, 1)
12122				}
12123				return res
12124			})
12125		default:
12126			panic("unknown field " + strconv.Quote(field.Name))
12127		}
12128	}
12129	out.Dispatch()
12130	if invalids > 0 {
12131		return graphql.Null
12132	}
12133	return out
12134}
12135
12136var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12137
12138func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12139	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12140
12141	out := graphql.NewFieldSet(fields)
12142	var invalids uint32
12143	for i, field := range fields {
12144		switch field.Name {
12145		case "__typename":
12146			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12147		case "id":
12148			field := field
12149			out.Concurrently(i, func() (res graphql.Marshaler) {
12150				defer func() {
12151					if r := recover(); r != nil {
12152						ec.Error(ctx, ec.Recover(ctx, r))
12153					}
12154				}()
12155				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12156				if res == graphql.Null {
12157					atomic.AddUint32(&invalids, 1)
12158				}
12159				return res
12160			})
12161		case "author":
12162			field := field
12163			out.Concurrently(i, func() (res graphql.Marshaler) {
12164				defer func() {
12165					if r := recover(); r != nil {
12166						ec.Error(ctx, ec.Recover(ctx, r))
12167					}
12168				}()
12169				res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12170				if res == graphql.Null {
12171					atomic.AddUint32(&invalids, 1)
12172				}
12173				return res
12174			})
12175		case "date":
12176			field := field
12177			out.Concurrently(i, func() (res graphql.Marshaler) {
12178				defer func() {
12179					if r := recover(); r != nil {
12180						ec.Error(ctx, ec.Recover(ctx, r))
12181					}
12182				}()
12183				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12184				if res == graphql.Null {
12185					atomic.AddUint32(&invalids, 1)
12186				}
12187				return res
12188			})
12189		case "status":
12190			field := field
12191			out.Concurrently(i, func() (res graphql.Marshaler) {
12192				defer func() {
12193					if r := recover(); r != nil {
12194						ec.Error(ctx, ec.Recover(ctx, r))
12195					}
12196				}()
12197				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12198				if res == graphql.Null {
12199					atomic.AddUint32(&invalids, 1)
12200				}
12201				return res
12202			})
12203		default:
12204			panic("unknown field " + strconv.Quote(field.Name))
12205		}
12206	}
12207	out.Dispatch()
12208	if invalids > 0 {
12209		return graphql.Null
12210	}
12211	return out
12212}
12213
12214var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12215
12216func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12217	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12218
12219	out := graphql.NewFieldSet(fields)
12220	var invalids uint32
12221	for i, field := range fields {
12222		switch field.Name {
12223		case "__typename":
12224			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12225		case "id":
12226			field := field
12227			out.Concurrently(i, func() (res graphql.Marshaler) {
12228				defer func() {
12229					if r := recover(); r != nil {
12230						ec.Error(ctx, ec.Recover(ctx, r))
12231					}
12232				}()
12233				res = ec._SetTitleOperation_id(ctx, field, obj)
12234				if res == graphql.Null {
12235					atomic.AddUint32(&invalids, 1)
12236				}
12237				return res
12238			})
12239		case "author":
12240			field := field
12241			out.Concurrently(i, func() (res graphql.Marshaler) {
12242				defer func() {
12243					if r := recover(); r != nil {
12244						ec.Error(ctx, ec.Recover(ctx, r))
12245					}
12246				}()
12247				res = ec._SetTitleOperation_author(ctx, field, obj)
12248				if res == graphql.Null {
12249					atomic.AddUint32(&invalids, 1)
12250				}
12251				return res
12252			})
12253		case "date":
12254			field := field
12255			out.Concurrently(i, func() (res graphql.Marshaler) {
12256				defer func() {
12257					if r := recover(); r != nil {
12258						ec.Error(ctx, ec.Recover(ctx, r))
12259					}
12260				}()
12261				res = ec._SetTitleOperation_date(ctx, field, obj)
12262				if res == graphql.Null {
12263					atomic.AddUint32(&invalids, 1)
12264				}
12265				return res
12266			})
12267		case "title":
12268			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12269			if out.Values[i] == graphql.Null {
12270				atomic.AddUint32(&invalids, 1)
12271			}
12272		case "was":
12273			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12274			if out.Values[i] == graphql.Null {
12275				atomic.AddUint32(&invalids, 1)
12276			}
12277		default:
12278			panic("unknown field " + strconv.Quote(field.Name))
12279		}
12280	}
12281	out.Dispatch()
12282	if invalids > 0 {
12283		return graphql.Null
12284	}
12285	return out
12286}
12287
12288var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12289
12290func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12291	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12292
12293	out := graphql.NewFieldSet(fields)
12294	var invalids uint32
12295	for i, field := range fields {
12296		switch field.Name {
12297		case "__typename":
12298			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12299		case "clientMutationId":
12300			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12301		case "bug":
12302			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12303			if out.Values[i] == graphql.Null {
12304				invalids++
12305			}
12306		case "operation":
12307			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12308			if out.Values[i] == graphql.Null {
12309				invalids++
12310			}
12311		default:
12312			panic("unknown field " + strconv.Quote(field.Name))
12313		}
12314	}
12315	out.Dispatch()
12316	if invalids > 0 {
12317		return graphql.Null
12318	}
12319	return out
12320}
12321
12322var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12323
12324func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12325	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12326
12327	out := graphql.NewFieldSet(fields)
12328	var invalids uint32
12329	for i, field := range fields {
12330		switch field.Name {
12331		case "__typename":
12332			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12333		case "id":
12334			field := field
12335			out.Concurrently(i, func() (res graphql.Marshaler) {
12336				defer func() {
12337					if r := recover(); r != nil {
12338						ec.Error(ctx, ec.Recover(ctx, r))
12339					}
12340				}()
12341				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12342				if res == graphql.Null {
12343					atomic.AddUint32(&invalids, 1)
12344				}
12345				return res
12346			})
12347		case "author":
12348			field := field
12349			out.Concurrently(i, func() (res graphql.Marshaler) {
12350				defer func() {
12351					if r := recover(); r != nil {
12352						ec.Error(ctx, ec.Recover(ctx, r))
12353					}
12354				}()
12355				res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12356				if res == graphql.Null {
12357					atomic.AddUint32(&invalids, 1)
12358				}
12359				return res
12360			})
12361		case "date":
12362			field := field
12363			out.Concurrently(i, func() (res graphql.Marshaler) {
12364				defer func() {
12365					if r := recover(); r != nil {
12366						ec.Error(ctx, ec.Recover(ctx, r))
12367					}
12368				}()
12369				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12370				if res == graphql.Null {
12371					atomic.AddUint32(&invalids, 1)
12372				}
12373				return res
12374			})
12375		case "title":
12376			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12377			if out.Values[i] == graphql.Null {
12378				atomic.AddUint32(&invalids, 1)
12379			}
12380		case "was":
12381			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12382			if out.Values[i] == graphql.Null {
12383				atomic.AddUint32(&invalids, 1)
12384			}
12385		default:
12386			panic("unknown field " + strconv.Quote(field.Name))
12387		}
12388	}
12389	out.Dispatch()
12390	if invalids > 0 {
12391		return graphql.Null
12392	}
12393	return out
12394}
12395
12396var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12397
12398func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12399	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12400
12401	out := graphql.NewFieldSet(fields)
12402	var invalids uint32
12403	for i, field := range fields {
12404		switch field.Name {
12405		case "__typename":
12406			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12407		case "edges":
12408			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12409			if out.Values[i] == graphql.Null {
12410				invalids++
12411			}
12412		case "nodes":
12413			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12414			if out.Values[i] == graphql.Null {
12415				invalids++
12416			}
12417		case "pageInfo":
12418			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12419			if out.Values[i] == graphql.Null {
12420				invalids++
12421			}
12422		case "totalCount":
12423			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12424			if out.Values[i] == graphql.Null {
12425				invalids++
12426			}
12427		default:
12428			panic("unknown field " + strconv.Quote(field.Name))
12429		}
12430	}
12431	out.Dispatch()
12432	if invalids > 0 {
12433		return graphql.Null
12434	}
12435	return out
12436}
12437
12438var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12439
12440func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12441	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12442
12443	out := graphql.NewFieldSet(fields)
12444	var invalids uint32
12445	for i, field := range fields {
12446		switch field.Name {
12447		case "__typename":
12448			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12449		case "cursor":
12450			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12451			if out.Values[i] == graphql.Null {
12452				invalids++
12453			}
12454		case "node":
12455			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12456			if out.Values[i] == graphql.Null {
12457				invalids++
12458			}
12459		default:
12460			panic("unknown field " + strconv.Quote(field.Name))
12461		}
12462	}
12463	out.Dispatch()
12464	if invalids > 0 {
12465		return graphql.Null
12466	}
12467	return out
12468}
12469
12470var __DirectiveImplementors = []string{"__Directive"}
12471
12472func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12473	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12474
12475	out := graphql.NewFieldSet(fields)
12476	var invalids uint32
12477	for i, field := range fields {
12478		switch field.Name {
12479		case "__typename":
12480			out.Values[i] = graphql.MarshalString("__Directive")
12481		case "name":
12482			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12483			if out.Values[i] == graphql.Null {
12484				invalids++
12485			}
12486		case "description":
12487			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12488		case "locations":
12489			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12490			if out.Values[i] == graphql.Null {
12491				invalids++
12492			}
12493		case "args":
12494			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12495			if out.Values[i] == graphql.Null {
12496				invalids++
12497			}
12498		default:
12499			panic("unknown field " + strconv.Quote(field.Name))
12500		}
12501	}
12502	out.Dispatch()
12503	if invalids > 0 {
12504		return graphql.Null
12505	}
12506	return out
12507}
12508
12509var __EnumValueImplementors = []string{"__EnumValue"}
12510
12511func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12512	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12513
12514	out := graphql.NewFieldSet(fields)
12515	var invalids uint32
12516	for i, field := range fields {
12517		switch field.Name {
12518		case "__typename":
12519			out.Values[i] = graphql.MarshalString("__EnumValue")
12520		case "name":
12521			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12522			if out.Values[i] == graphql.Null {
12523				invalids++
12524			}
12525		case "description":
12526			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12527		case "isDeprecated":
12528			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12529			if out.Values[i] == graphql.Null {
12530				invalids++
12531			}
12532		case "deprecationReason":
12533			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12534		default:
12535			panic("unknown field " + strconv.Quote(field.Name))
12536		}
12537	}
12538	out.Dispatch()
12539	if invalids > 0 {
12540		return graphql.Null
12541	}
12542	return out
12543}
12544
12545var __FieldImplementors = []string{"__Field"}
12546
12547func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12548	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
12549
12550	out := graphql.NewFieldSet(fields)
12551	var invalids uint32
12552	for i, field := range fields {
12553		switch field.Name {
12554		case "__typename":
12555			out.Values[i] = graphql.MarshalString("__Field")
12556		case "name":
12557			out.Values[i] = ec.___Field_name(ctx, field, obj)
12558			if out.Values[i] == graphql.Null {
12559				invalids++
12560			}
12561		case "description":
12562			out.Values[i] = ec.___Field_description(ctx, field, obj)
12563		case "args":
12564			out.Values[i] = ec.___Field_args(ctx, field, obj)
12565			if out.Values[i] == graphql.Null {
12566				invalids++
12567			}
12568		case "type":
12569			out.Values[i] = ec.___Field_type(ctx, field, obj)
12570			if out.Values[i] == graphql.Null {
12571				invalids++
12572			}
12573		case "isDeprecated":
12574			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
12575			if out.Values[i] == graphql.Null {
12576				invalids++
12577			}
12578		case "deprecationReason":
12579			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
12580		default:
12581			panic("unknown field " + strconv.Quote(field.Name))
12582		}
12583	}
12584	out.Dispatch()
12585	if invalids > 0 {
12586		return graphql.Null
12587	}
12588	return out
12589}
12590
12591var __InputValueImplementors = []string{"__InputValue"}
12592
12593func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
12594	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
12595
12596	out := graphql.NewFieldSet(fields)
12597	var invalids uint32
12598	for i, field := range fields {
12599		switch field.Name {
12600		case "__typename":
12601			out.Values[i] = graphql.MarshalString("__InputValue")
12602		case "name":
12603			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
12604			if out.Values[i] == graphql.Null {
12605				invalids++
12606			}
12607		case "description":
12608			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
12609		case "type":
12610			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
12611			if out.Values[i] == graphql.Null {
12612				invalids++
12613			}
12614		case "defaultValue":
12615			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
12616		default:
12617			panic("unknown field " + strconv.Quote(field.Name))
12618		}
12619	}
12620	out.Dispatch()
12621	if invalids > 0 {
12622		return graphql.Null
12623	}
12624	return out
12625}
12626
12627var __SchemaImplementors = []string{"__Schema"}
12628
12629func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
12630	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
12631
12632	out := graphql.NewFieldSet(fields)
12633	var invalids uint32
12634	for i, field := range fields {
12635		switch field.Name {
12636		case "__typename":
12637			out.Values[i] = graphql.MarshalString("__Schema")
12638		case "types":
12639			out.Values[i] = ec.___Schema_types(ctx, field, obj)
12640			if out.Values[i] == graphql.Null {
12641				invalids++
12642			}
12643		case "queryType":
12644			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
12645			if out.Values[i] == graphql.Null {
12646				invalids++
12647			}
12648		case "mutationType":
12649			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
12650		case "subscriptionType":
12651			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
12652		case "directives":
12653			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
12654			if out.Values[i] == graphql.Null {
12655				invalids++
12656			}
12657		default:
12658			panic("unknown field " + strconv.Quote(field.Name))
12659		}
12660	}
12661	out.Dispatch()
12662	if invalids > 0 {
12663		return graphql.Null
12664	}
12665	return out
12666}
12667
12668var __TypeImplementors = []string{"__Type"}
12669
12670func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
12671	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
12672
12673	out := graphql.NewFieldSet(fields)
12674	var invalids uint32
12675	for i, field := range fields {
12676		switch field.Name {
12677		case "__typename":
12678			out.Values[i] = graphql.MarshalString("__Type")
12679		case "kind":
12680			out.Values[i] = ec.___Type_kind(ctx, field, obj)
12681			if out.Values[i] == graphql.Null {
12682				invalids++
12683			}
12684		case "name":
12685			out.Values[i] = ec.___Type_name(ctx, field, obj)
12686		case "description":
12687			out.Values[i] = ec.___Type_description(ctx, field, obj)
12688		case "fields":
12689			out.Values[i] = ec.___Type_fields(ctx, field, obj)
12690		case "interfaces":
12691			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
12692		case "possibleTypes":
12693			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
12694		case "enumValues":
12695			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
12696		case "inputFields":
12697			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
12698		case "ofType":
12699			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
12700		default:
12701			panic("unknown field " + strconv.Quote(field.Name))
12702		}
12703	}
12704	out.Dispatch()
12705	if invalids > 0 {
12706		return graphql.Null
12707	}
12708	return out
12709}
12710
12711// endregion **************************** object.gotpl ****************************
12712
12713// region    ***************************** type.gotpl *****************************
12714
12715func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
12716	return ec.unmarshalInputAddCommentInput(ctx, v)
12717}
12718
12719func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
12720	return ec._AddCommentOperation(ctx, sel, &v)
12721}
12722
12723func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
12724	if v == nil {
12725		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12726			ec.Errorf(ctx, "must not be null")
12727		}
12728		return graphql.Null
12729	}
12730	return ec._AddCommentOperation(ctx, sel, v)
12731}
12732
12733func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
12734	return ec._AddCommentPayload(ctx, sel, &v)
12735}
12736
12737func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
12738	if v == nil {
12739		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12740			ec.Errorf(ctx, "must not be null")
12741		}
12742		return graphql.Null
12743	}
12744	return ec._AddCommentPayload(ctx, sel, v)
12745}
12746
12747func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
12748	return graphql.UnmarshalBoolean(v)
12749}
12750
12751func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
12752	res := graphql.MarshalBoolean(v)
12753	if res == graphql.Null {
12754		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12755			ec.Errorf(ctx, "must not be null")
12756		}
12757	}
12758	return res
12759}
12760
12761func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
12762	if v == nil {
12763		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12764			ec.Errorf(ctx, "must not be null")
12765		}
12766		return graphql.Null
12767	}
12768	return ec._Bug(ctx, sel, v)
12769}
12770
12771func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
12772	ret := make(graphql.Array, len(v))
12773	var wg sync.WaitGroup
12774	isLen1 := len(v) == 1
12775	if !isLen1 {
12776		wg.Add(len(v))
12777	}
12778	for i := range v {
12779		i := i
12780		fc := &graphql.FieldContext{
12781			Index:  &i,
12782			Result: &v[i],
12783		}
12784		ctx := graphql.WithFieldContext(ctx, fc)
12785		f := func(i int) {
12786			defer func() {
12787				if r := recover(); r != nil {
12788					ec.Error(ctx, ec.Recover(ctx, r))
12789					ret = nil
12790				}
12791			}()
12792			if !isLen1 {
12793				defer wg.Done()
12794			}
12795			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
12796		}
12797		if isLen1 {
12798			f(i)
12799		} else {
12800			go f(i)
12801		}
12802
12803	}
12804	wg.Wait()
12805	return ret
12806}
12807
12808func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
12809	return ec._BugConnection(ctx, sel, &v)
12810}
12811
12812func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
12813	if v == nil {
12814		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12815			ec.Errorf(ctx, "must not be null")
12816		}
12817		return graphql.Null
12818	}
12819	return ec._BugConnection(ctx, sel, v)
12820}
12821
12822func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
12823	return ec._BugEdge(ctx, sel, &v)
12824}
12825
12826func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
12827	ret := make(graphql.Array, len(v))
12828	var wg sync.WaitGroup
12829	isLen1 := len(v) == 1
12830	if !isLen1 {
12831		wg.Add(len(v))
12832	}
12833	for i := range v {
12834		i := i
12835		fc := &graphql.FieldContext{
12836			Index:  &i,
12837			Result: &v[i],
12838		}
12839		ctx := graphql.WithFieldContext(ctx, fc)
12840		f := func(i int) {
12841			defer func() {
12842				if r := recover(); r != nil {
12843					ec.Error(ctx, ec.Recover(ctx, r))
12844					ret = nil
12845				}
12846			}()
12847			if !isLen1 {
12848				defer wg.Done()
12849			}
12850			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
12851		}
12852		if isLen1 {
12853			f(i)
12854		} else {
12855			go f(i)
12856		}
12857
12858	}
12859	wg.Wait()
12860	return ret
12861}
12862
12863func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
12864	if v == nil {
12865		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12866			ec.Errorf(ctx, "must not be null")
12867		}
12868		return graphql.Null
12869	}
12870	return ec._BugEdge(ctx, sel, v)
12871}
12872
12873func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
12874	return ec._ChangeLabelPayload(ctx, sel, &v)
12875}
12876
12877func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
12878	if v == nil {
12879		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12880			ec.Errorf(ctx, "must not be null")
12881		}
12882		return graphql.Null
12883	}
12884	return ec._ChangeLabelPayload(ctx, sel, v)
12885}
12886
12887func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
12888	return ec.unmarshalInputCloseBugInput(ctx, v)
12889}
12890
12891func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
12892	return ec._CloseBugPayload(ctx, sel, &v)
12893}
12894
12895func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
12896	if v == nil {
12897		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12898			ec.Errorf(ctx, "must not be null")
12899		}
12900		return graphql.Null
12901	}
12902	return ec._CloseBugPayload(ctx, sel, v)
12903}
12904
12905func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
12906	return ec._Color(ctx, sel, &v)
12907}
12908
12909func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
12910	if v == nil {
12911		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12912			ec.Errorf(ctx, "must not be null")
12913		}
12914		return graphql.Null
12915	}
12916	return ec._Color(ctx, sel, v)
12917}
12918
12919func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
12920	return ec._Comment(ctx, sel, &v)
12921}
12922
12923func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
12924	ret := make(graphql.Array, len(v))
12925	var wg sync.WaitGroup
12926	isLen1 := len(v) == 1
12927	if !isLen1 {
12928		wg.Add(len(v))
12929	}
12930	for i := range v {
12931		i := i
12932		fc := &graphql.FieldContext{
12933			Index:  &i,
12934			Result: &v[i],
12935		}
12936		ctx := graphql.WithFieldContext(ctx, fc)
12937		f := func(i int) {
12938			defer func() {
12939				if r := recover(); r != nil {
12940					ec.Error(ctx, ec.Recover(ctx, r))
12941					ret = nil
12942				}
12943			}()
12944			if !isLen1 {
12945				defer wg.Done()
12946			}
12947			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
12948		}
12949		if isLen1 {
12950			f(i)
12951		} else {
12952			go f(i)
12953		}
12954
12955	}
12956	wg.Wait()
12957	return ret
12958}
12959
12960func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
12961	if v == nil {
12962		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12963			ec.Errorf(ctx, "must not be null")
12964		}
12965		return graphql.Null
12966	}
12967	return ec._Comment(ctx, sel, v)
12968}
12969
12970func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
12971	return ec._CommentConnection(ctx, sel, &v)
12972}
12973
12974func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
12975	if v == nil {
12976		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
12977			ec.Errorf(ctx, "must not be null")
12978		}
12979		return graphql.Null
12980	}
12981	return ec._CommentConnection(ctx, sel, v)
12982}
12983
12984func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
12985	return ec._CommentEdge(ctx, sel, &v)
12986}
12987
12988func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
12989	ret := make(graphql.Array, len(v))
12990	var wg sync.WaitGroup
12991	isLen1 := len(v) == 1
12992	if !isLen1 {
12993		wg.Add(len(v))
12994	}
12995	for i := range v {
12996		i := i
12997		fc := &graphql.FieldContext{
12998			Index:  &i,
12999			Result: &v[i],
13000		}
13001		ctx := graphql.WithFieldContext(ctx, fc)
13002		f := func(i int) {
13003			defer func() {
13004				if r := recover(); r != nil {
13005					ec.Error(ctx, ec.Recover(ctx, r))
13006					ret = nil
13007				}
13008			}()
13009			if !isLen1 {
13010				defer wg.Done()
13011			}
13012			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13013		}
13014		if isLen1 {
13015			f(i)
13016		} else {
13017			go f(i)
13018		}
13019
13020	}
13021	wg.Wait()
13022	return ret
13023}
13024
13025func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13026	if v == nil {
13027		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13028			ec.Errorf(ctx, "must not be null")
13029		}
13030		return graphql.Null
13031	}
13032	return ec._CommentEdge(ctx, sel, v)
13033}
13034
13035func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13036	return ec._CommentHistoryStep(ctx, sel, &v)
13037}
13038
13039func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13040	ret := make(graphql.Array, len(v))
13041	var wg sync.WaitGroup
13042	isLen1 := len(v) == 1
13043	if !isLen1 {
13044		wg.Add(len(v))
13045	}
13046	for i := range v {
13047		i := i
13048		fc := &graphql.FieldContext{
13049			Index:  &i,
13050			Result: &v[i],
13051		}
13052		ctx := graphql.WithFieldContext(ctx, fc)
13053		f := func(i int) {
13054			defer func() {
13055				if r := recover(); r != nil {
13056					ec.Error(ctx, ec.Recover(ctx, r))
13057					ret = nil
13058				}
13059			}()
13060			if !isLen1 {
13061				defer wg.Done()
13062			}
13063			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13064		}
13065		if isLen1 {
13066			f(i)
13067		} else {
13068			go f(i)
13069		}
13070
13071	}
13072	wg.Wait()
13073	return ret
13074}
13075
13076func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13077	return ec._CreateOperation(ctx, sel, &v)
13078}
13079
13080func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13081	if v == nil {
13082		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13083			ec.Errorf(ctx, "must not be null")
13084		}
13085		return graphql.Null
13086	}
13087	return ec._CreateOperation(ctx, sel, v)
13088}
13089
13090func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13091	var res git.Hash
13092	return res, res.UnmarshalGQL(v)
13093}
13094
13095func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13096	return v
13097}
13098
13099func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13100	var vSlice []interface{}
13101	if v != nil {
13102		if tmp1, ok := v.([]interface{}); ok {
13103			vSlice = tmp1
13104		} else {
13105			vSlice = []interface{}{v}
13106		}
13107	}
13108	var err error
13109	res := make([]git.Hash, len(vSlice))
13110	for i := range vSlice {
13111		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13112		if err != nil {
13113			return nil, err
13114		}
13115	}
13116	return res, nil
13117}
13118
13119func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13120	ret := make(graphql.Array, len(v))
13121	for i := range v {
13122		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13123	}
13124
13125	return ret
13126}
13127
13128func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13129	if v == nil {
13130		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13131			ec.Errorf(ctx, "must not be null")
13132		}
13133		return graphql.Null
13134	}
13135	return ec._Identity(ctx, sel, v)
13136}
13137
13138func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13139	ret := make(graphql.Array, len(v))
13140	var wg sync.WaitGroup
13141	isLen1 := len(v) == 1
13142	if !isLen1 {
13143		wg.Add(len(v))
13144	}
13145	for i := range v {
13146		i := i
13147		fc := &graphql.FieldContext{
13148			Index:  &i,
13149			Result: &v[i],
13150		}
13151		ctx := graphql.WithFieldContext(ctx, fc)
13152		f := func(i int) {
13153			defer func() {
13154				if r := recover(); r != nil {
13155					ec.Error(ctx, ec.Recover(ctx, r))
13156					ret = nil
13157				}
13158			}()
13159			if !isLen1 {
13160				defer wg.Done()
13161			}
13162			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13163		}
13164		if isLen1 {
13165			f(i)
13166		} else {
13167			go f(i)
13168		}
13169
13170	}
13171	wg.Wait()
13172	return ret
13173}
13174
13175func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13176	return ec._IdentityConnection(ctx, sel, &v)
13177}
13178
13179func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13180	if v == nil {
13181		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13182			ec.Errorf(ctx, "must not be null")
13183		}
13184		return graphql.Null
13185	}
13186	return ec._IdentityConnection(ctx, sel, v)
13187}
13188
13189func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13190	return ec._IdentityEdge(ctx, sel, &v)
13191}
13192
13193func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13194	ret := make(graphql.Array, len(v))
13195	var wg sync.WaitGroup
13196	isLen1 := len(v) == 1
13197	if !isLen1 {
13198		wg.Add(len(v))
13199	}
13200	for i := range v {
13201		i := i
13202		fc := &graphql.FieldContext{
13203			Index:  &i,
13204			Result: &v[i],
13205		}
13206		ctx := graphql.WithFieldContext(ctx, fc)
13207		f := func(i int) {
13208			defer func() {
13209				if r := recover(); r != nil {
13210					ec.Error(ctx, ec.Recover(ctx, r))
13211					ret = nil
13212				}
13213			}()
13214			if !isLen1 {
13215				defer wg.Done()
13216			}
13217			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13218		}
13219		if isLen1 {
13220			f(i)
13221		} else {
13222			go f(i)
13223		}
13224
13225	}
13226	wg.Wait()
13227	return ret
13228}
13229
13230func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13231	if v == nil {
13232		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13233			ec.Errorf(ctx, "must not be null")
13234		}
13235		return graphql.Null
13236	}
13237	return ec._IdentityEdge(ctx, sel, v)
13238}
13239
13240func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13241	return graphql.UnmarshalInt(v)
13242}
13243
13244func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13245	res := graphql.MarshalInt(v)
13246	if res == graphql.Null {
13247		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13248			ec.Errorf(ctx, "must not be null")
13249		}
13250	}
13251	return res
13252}
13253
13254func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13255	return ec._Label(ctx, sel, &v)
13256}
13257
13258func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13259	ret := make(graphql.Array, len(v))
13260	var wg sync.WaitGroup
13261	isLen1 := len(v) == 1
13262	if !isLen1 {
13263		wg.Add(len(v))
13264	}
13265	for i := range v {
13266		i := i
13267		fc := &graphql.FieldContext{
13268			Index:  &i,
13269			Result: &v[i],
13270		}
13271		ctx := graphql.WithFieldContext(ctx, fc)
13272		f := func(i int) {
13273			defer func() {
13274				if r := recover(); r != nil {
13275					ec.Error(ctx, ec.Recover(ctx, r))
13276					ret = nil
13277				}
13278			}()
13279			if !isLen1 {
13280				defer wg.Done()
13281			}
13282			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13283		}
13284		if isLen1 {
13285			f(i)
13286		} else {
13287			go f(i)
13288		}
13289
13290	}
13291	wg.Wait()
13292	return ret
13293}
13294
13295func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13296	return ec._LabelChangeOperation(ctx, sel, &v)
13297}
13298
13299func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13300	if v == nil {
13301		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13302			ec.Errorf(ctx, "must not be null")
13303		}
13304		return graphql.Null
13305	}
13306	return ec._LabelChangeOperation(ctx, sel, v)
13307}
13308
13309func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13310	ret := make(graphql.Array, len(v))
13311	var wg sync.WaitGroup
13312	isLen1 := len(v) == 1
13313	if !isLen1 {
13314		wg.Add(len(v))
13315	}
13316	for i := range v {
13317		i := i
13318		fc := &graphql.FieldContext{
13319			Index:  &i,
13320			Result: &v[i],
13321		}
13322		ctx := graphql.WithFieldContext(ctx, fc)
13323		f := func(i int) {
13324			defer func() {
13325				if r := recover(); r != nil {
13326					ec.Error(ctx, ec.Recover(ctx, r))
13327					ret = nil
13328				}
13329			}()
13330			if !isLen1 {
13331				defer wg.Done()
13332			}
13333			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13334		}
13335		if isLen1 {
13336			f(i)
13337		} else {
13338			go f(i)
13339		}
13340
13341	}
13342	wg.Wait()
13343	return ret
13344}
13345
13346func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13347	var res models.LabelChangeStatus
13348	return res, res.UnmarshalGQL(v)
13349}
13350
13351func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13352	return v
13353}
13354
13355func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13356	return ec._LabelConnection(ctx, sel, &v)
13357}
13358
13359func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13360	if v == nil {
13361		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13362			ec.Errorf(ctx, "must not be null")
13363		}
13364		return graphql.Null
13365	}
13366	return ec._LabelConnection(ctx, sel, v)
13367}
13368
13369func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13370	return ec._LabelEdge(ctx, sel, &v)
13371}
13372
13373func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13374	ret := make(graphql.Array, len(v))
13375	var wg sync.WaitGroup
13376	isLen1 := len(v) == 1
13377	if !isLen1 {
13378		wg.Add(len(v))
13379	}
13380	for i := range v {
13381		i := i
13382		fc := &graphql.FieldContext{
13383			Index:  &i,
13384			Result: &v[i],
13385		}
13386		ctx := graphql.WithFieldContext(ctx, fc)
13387		f := func(i int) {
13388			defer func() {
13389				if r := recover(); r != nil {
13390					ec.Error(ctx, ec.Recover(ctx, r))
13391					ret = nil
13392				}
13393			}()
13394			if !isLen1 {
13395				defer wg.Done()
13396			}
13397			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13398		}
13399		if isLen1 {
13400			f(i)
13401		} else {
13402			go f(i)
13403		}
13404
13405	}
13406	wg.Wait()
13407	return ret
13408}
13409
13410func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13411	if v == nil {
13412		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13413			ec.Errorf(ctx, "must not be null")
13414		}
13415		return graphql.Null
13416	}
13417	return ec._LabelEdge(ctx, sel, v)
13418}
13419
13420func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13421	return ec.unmarshalInputNewBugInput(ctx, v)
13422}
13423
13424func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13425	return ec._NewBugPayload(ctx, sel, &v)
13426}
13427
13428func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13429	if v == nil {
13430		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13431			ec.Errorf(ctx, "must not be null")
13432		}
13433		return graphql.Null
13434	}
13435	return ec._NewBugPayload(ctx, sel, v)
13436}
13437
13438func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13439	return ec.unmarshalInputOpenBugInput(ctx, v)
13440}
13441
13442func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13443	return ec._OpenBugPayload(ctx, sel, &v)
13444}
13445
13446func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13447	if v == nil {
13448		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13449			ec.Errorf(ctx, "must not be null")
13450		}
13451		return graphql.Null
13452	}
13453	return ec._OpenBugPayload(ctx, sel, v)
13454}
13455
13456func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13457	if v == nil {
13458		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13459			ec.Errorf(ctx, "must not be null")
13460		}
13461		return graphql.Null
13462	}
13463	return ec._Operation(ctx, sel, v)
13464}
13465
13466func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13467	ret := make(graphql.Array, len(v))
13468	var wg sync.WaitGroup
13469	isLen1 := len(v) == 1
13470	if !isLen1 {
13471		wg.Add(len(v))
13472	}
13473	for i := range v {
13474		i := i
13475		fc := &graphql.FieldContext{
13476			Index:  &i,
13477			Result: &v[i],
13478		}
13479		ctx := graphql.WithFieldContext(ctx, fc)
13480		f := func(i int) {
13481			defer func() {
13482				if r := recover(); r != nil {
13483					ec.Error(ctx, ec.Recover(ctx, r))
13484					ret = nil
13485				}
13486			}()
13487			if !isLen1 {
13488				defer wg.Done()
13489			}
13490			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13491		}
13492		if isLen1 {
13493			f(i)
13494		} else {
13495			go f(i)
13496		}
13497
13498	}
13499	wg.Wait()
13500	return ret
13501}
13502
13503func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13504	return ec._OperationConnection(ctx, sel, &v)
13505}
13506
13507func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13508	if v == nil {
13509		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13510			ec.Errorf(ctx, "must not be null")
13511		}
13512		return graphql.Null
13513	}
13514	return ec._OperationConnection(ctx, sel, v)
13515}
13516
13517func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13518	return ec._OperationEdge(ctx, sel, &v)
13519}
13520
13521func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13522	ret := make(graphql.Array, len(v))
13523	var wg sync.WaitGroup
13524	isLen1 := len(v) == 1
13525	if !isLen1 {
13526		wg.Add(len(v))
13527	}
13528	for i := range v {
13529		i := i
13530		fc := &graphql.FieldContext{
13531			Index:  &i,
13532			Result: &v[i],
13533		}
13534		ctx := graphql.WithFieldContext(ctx, fc)
13535		f := func(i int) {
13536			defer func() {
13537				if r := recover(); r != nil {
13538					ec.Error(ctx, ec.Recover(ctx, r))
13539					ret = nil
13540				}
13541			}()
13542			if !isLen1 {
13543				defer wg.Done()
13544			}
13545			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13546		}
13547		if isLen1 {
13548			f(i)
13549		} else {
13550			go f(i)
13551		}
13552
13553	}
13554	wg.Wait()
13555	return ret
13556}
13557
13558func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
13559	if v == nil {
13560		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13561			ec.Errorf(ctx, "must not be null")
13562		}
13563		return graphql.Null
13564	}
13565	return ec._OperationEdge(ctx, sel, v)
13566}
13567
13568func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
13569	return ec._PageInfo(ctx, sel, &v)
13570}
13571
13572func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
13573	if v == nil {
13574		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13575			ec.Errorf(ctx, "must not be null")
13576		}
13577		return graphql.Null
13578	}
13579	return ec._PageInfo(ctx, sel, v)
13580}
13581
13582func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
13583	return ec._SetStatusOperation(ctx, sel, &v)
13584}
13585
13586func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
13587	if v == nil {
13588		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13589			ec.Errorf(ctx, "must not be null")
13590		}
13591		return graphql.Null
13592	}
13593	return ec._SetStatusOperation(ctx, sel, v)
13594}
13595
13596func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
13597	return ec.unmarshalInputSetTitleInput(ctx, v)
13598}
13599
13600func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
13601	return ec._SetTitleOperation(ctx, sel, &v)
13602}
13603
13604func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
13605	if v == nil {
13606		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13607			ec.Errorf(ctx, "must not be null")
13608		}
13609		return graphql.Null
13610	}
13611	return ec._SetTitleOperation(ctx, sel, v)
13612}
13613
13614func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
13615	return ec._SetTitlePayload(ctx, sel, &v)
13616}
13617
13618func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
13619	if v == nil {
13620		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13621			ec.Errorf(ctx, "must not be null")
13622		}
13623		return graphql.Null
13624	}
13625	return ec._SetTitlePayload(ctx, sel, v)
13626}
13627
13628func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
13629	var res models.Status
13630	return res, res.UnmarshalGQL(v)
13631}
13632
13633func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
13634	return v
13635}
13636
13637func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
13638	return graphql.UnmarshalString(v)
13639}
13640
13641func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13642	res := graphql.MarshalString(v)
13643	if res == graphql.Null {
13644		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13645			ec.Errorf(ctx, "must not be null")
13646		}
13647	}
13648	return res
13649}
13650
13651func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
13652	return graphql.UnmarshalTime(v)
13653}
13654
13655func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
13656	res := graphql.MarshalTime(v)
13657	if res == graphql.Null {
13658		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13659			ec.Errorf(ctx, "must not be null")
13660		}
13661	}
13662	return res
13663}
13664
13665func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
13666	if v == nil {
13667		return nil, nil
13668	}
13669	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
13670	return &res, err
13671}
13672
13673func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
13674	if v == nil {
13675		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13676			ec.Errorf(ctx, "must not be null")
13677		}
13678		return graphql.Null
13679	}
13680	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
13681}
13682
13683func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
13684	if v == nil {
13685		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13686			ec.Errorf(ctx, "must not be null")
13687		}
13688		return graphql.Null
13689	}
13690	return ec._TimelineItem(ctx, sel, v)
13691}
13692
13693func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
13694	ret := make(graphql.Array, len(v))
13695	var wg sync.WaitGroup
13696	isLen1 := len(v) == 1
13697	if !isLen1 {
13698		wg.Add(len(v))
13699	}
13700	for i := range v {
13701		i := i
13702		fc := &graphql.FieldContext{
13703			Index:  &i,
13704			Result: &v[i],
13705		}
13706		ctx := graphql.WithFieldContext(ctx, fc)
13707		f := func(i int) {
13708			defer func() {
13709				if r := recover(); r != nil {
13710					ec.Error(ctx, ec.Recover(ctx, r))
13711					ret = nil
13712				}
13713			}()
13714			if !isLen1 {
13715				defer wg.Done()
13716			}
13717			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
13718		}
13719		if isLen1 {
13720			f(i)
13721		} else {
13722			go f(i)
13723		}
13724
13725	}
13726	wg.Wait()
13727	return ret
13728}
13729
13730func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
13731	return ec._TimelineItemConnection(ctx, sel, &v)
13732}
13733
13734func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
13735	if v == nil {
13736		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13737			ec.Errorf(ctx, "must not be null")
13738		}
13739		return graphql.Null
13740	}
13741	return ec._TimelineItemConnection(ctx, sel, v)
13742}
13743
13744func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
13745	return ec._TimelineItemEdge(ctx, sel, &v)
13746}
13747
13748func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
13749	ret := make(graphql.Array, len(v))
13750	var wg sync.WaitGroup
13751	isLen1 := len(v) == 1
13752	if !isLen1 {
13753		wg.Add(len(v))
13754	}
13755	for i := range v {
13756		i := i
13757		fc := &graphql.FieldContext{
13758			Index:  &i,
13759			Result: &v[i],
13760		}
13761		ctx := graphql.WithFieldContext(ctx, fc)
13762		f := func(i int) {
13763			defer func() {
13764				if r := recover(); r != nil {
13765					ec.Error(ctx, ec.Recover(ctx, r))
13766					ret = nil
13767				}
13768			}()
13769			if !isLen1 {
13770				defer wg.Done()
13771			}
13772			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
13773		}
13774		if isLen1 {
13775			f(i)
13776		} else {
13777			go f(i)
13778		}
13779
13780	}
13781	wg.Wait()
13782	return ret
13783}
13784
13785func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
13786	if v == nil {
13787		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13788			ec.Errorf(ctx, "must not be null")
13789		}
13790		return graphql.Null
13791	}
13792	return ec._TimelineItemEdge(ctx, sel, v)
13793}
13794
13795func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
13796	return ec.___Directive(ctx, sel, &v)
13797}
13798
13799func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
13800	ret := make(graphql.Array, len(v))
13801	var wg sync.WaitGroup
13802	isLen1 := len(v) == 1
13803	if !isLen1 {
13804		wg.Add(len(v))
13805	}
13806	for i := range v {
13807		i := i
13808		fc := &graphql.FieldContext{
13809			Index:  &i,
13810			Result: &v[i],
13811		}
13812		ctx := graphql.WithFieldContext(ctx, fc)
13813		f := func(i int) {
13814			defer func() {
13815				if r := recover(); r != nil {
13816					ec.Error(ctx, ec.Recover(ctx, r))
13817					ret = nil
13818				}
13819			}()
13820			if !isLen1 {
13821				defer wg.Done()
13822			}
13823			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
13824		}
13825		if isLen1 {
13826			f(i)
13827		} else {
13828			go f(i)
13829		}
13830
13831	}
13832	wg.Wait()
13833	return ret
13834}
13835
13836func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
13837	return graphql.UnmarshalString(v)
13838}
13839
13840func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
13841	res := graphql.MarshalString(v)
13842	if res == graphql.Null {
13843		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13844			ec.Errorf(ctx, "must not be null")
13845		}
13846	}
13847	return res
13848}
13849
13850func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
13851	var vSlice []interface{}
13852	if v != nil {
13853		if tmp1, ok := v.([]interface{}); ok {
13854			vSlice = tmp1
13855		} else {
13856			vSlice = []interface{}{v}
13857		}
13858	}
13859	var err error
13860	res := make([]string, len(vSlice))
13861	for i := range vSlice {
13862		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
13863		if err != nil {
13864			return nil, err
13865		}
13866	}
13867	return res, nil
13868}
13869
13870func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
13871	ret := make(graphql.Array, len(v))
13872	var wg sync.WaitGroup
13873	isLen1 := len(v) == 1
13874	if !isLen1 {
13875		wg.Add(len(v))
13876	}
13877	for i := range v {
13878		i := i
13879		fc := &graphql.FieldContext{
13880			Index:  &i,
13881			Result: &v[i],
13882		}
13883		ctx := graphql.WithFieldContext(ctx, fc)
13884		f := func(i int) {
13885			defer func() {
13886				if r := recover(); r != nil {
13887					ec.Error(ctx, ec.Recover(ctx, r))
13888					ret = nil
13889				}
13890			}()
13891			if !isLen1 {
13892				defer wg.Done()
13893			}
13894			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
13895		}
13896		if isLen1 {
13897			f(i)
13898		} else {
13899			go f(i)
13900		}
13901
13902	}
13903	wg.Wait()
13904	return ret
13905}
13906
13907func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
13908	return ec.___EnumValue(ctx, sel, &v)
13909}
13910
13911func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
13912	return ec.___Field(ctx, sel, &v)
13913}
13914
13915func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
13916	return ec.___InputValue(ctx, sel, &v)
13917}
13918
13919func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
13920	ret := make(graphql.Array, len(v))
13921	var wg sync.WaitGroup
13922	isLen1 := len(v) == 1
13923	if !isLen1 {
13924		wg.Add(len(v))
13925	}
13926	for i := range v {
13927		i := i
13928		fc := &graphql.FieldContext{
13929			Index:  &i,
13930			Result: &v[i],
13931		}
13932		ctx := graphql.WithFieldContext(ctx, fc)
13933		f := func(i int) {
13934			defer func() {
13935				if r := recover(); r != nil {
13936					ec.Error(ctx, ec.Recover(ctx, r))
13937					ret = nil
13938				}
13939			}()
13940			if !isLen1 {
13941				defer wg.Done()
13942			}
13943			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
13944		}
13945		if isLen1 {
13946			f(i)
13947		} else {
13948			go f(i)
13949		}
13950
13951	}
13952	wg.Wait()
13953	return ret
13954}
13955
13956func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
13957	return ec.___Type(ctx, sel, &v)
13958}
13959
13960func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
13961	ret := make(graphql.Array, len(v))
13962	var wg sync.WaitGroup
13963	isLen1 := len(v) == 1
13964	if !isLen1 {
13965		wg.Add(len(v))
13966	}
13967	for i := range v {
13968		i := i
13969		fc := &graphql.FieldContext{
13970			Index:  &i,
13971			Result: &v[i],
13972		}
13973		ctx := graphql.WithFieldContext(ctx, fc)
13974		f := func(i int) {
13975			defer func() {
13976				if r := recover(); r != nil {
13977					ec.Error(ctx, ec.Recover(ctx, r))
13978					ret = nil
13979				}
13980			}()
13981			if !isLen1 {
13982				defer wg.Done()
13983			}
13984			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
13985		}
13986		if isLen1 {
13987			f(i)
13988		} else {
13989			go f(i)
13990		}
13991
13992	}
13993	wg.Wait()
13994	return ret
13995}
13996
13997func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
13998	if v == nil {
13999		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14000			ec.Errorf(ctx, "must not be null")
14001		}
14002		return graphql.Null
14003	}
14004	return ec.___Type(ctx, sel, v)
14005}
14006
14007func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14008	return graphql.UnmarshalString(v)
14009}
14010
14011func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14012	res := graphql.MarshalString(v)
14013	if res == graphql.Null {
14014		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14015			ec.Errorf(ctx, "must not be null")
14016		}
14017	}
14018	return res
14019}
14020
14021func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14022	return graphql.UnmarshalBoolean(v)
14023}
14024
14025func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14026	return graphql.MarshalBoolean(v)
14027}
14028
14029func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14030	if v == nil {
14031		return nil, nil
14032	}
14033	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14034	return &res, err
14035}
14036
14037func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14038	if v == nil {
14039		return graphql.Null
14040	}
14041	return ec.marshalOBoolean2bool(ctx, sel, *v)
14042}
14043
14044func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14045	if v == nil {
14046		return graphql.Null
14047	}
14048	return ec._Bug(ctx, sel, v)
14049}
14050
14051func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14052	return ec.unmarshalInputChangeLabelInput(ctx, v)
14053}
14054
14055func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14056	if v == nil {
14057		return nil, nil
14058	}
14059	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14060	return &res, err
14061}
14062
14063func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14064	var vSlice []interface{}
14065	if v != nil {
14066		if tmp1, ok := v.([]interface{}); ok {
14067			vSlice = tmp1
14068		} else {
14069			vSlice = []interface{}{v}
14070		}
14071	}
14072	var err error
14073	res := make([]git.Hash, len(vSlice))
14074	for i := range vSlice {
14075		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14076		if err != nil {
14077			return nil, err
14078		}
14079	}
14080	return res, nil
14081}
14082
14083func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14084	if v == nil {
14085		return graphql.Null
14086	}
14087	ret := make(graphql.Array, len(v))
14088	for i := range v {
14089		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14090	}
14091
14092	return ret
14093}
14094
14095func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14096	if v == nil {
14097		return graphql.Null
14098	}
14099	return ec._Identity(ctx, sel, v)
14100}
14101
14102func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14103	return graphql.UnmarshalInt(v)
14104}
14105
14106func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14107	return graphql.MarshalInt(v)
14108}
14109
14110func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14111	if v == nil {
14112		return nil, nil
14113	}
14114	res, err := ec.unmarshalOInt2int(ctx, v)
14115	return &res, err
14116}
14117
14118func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14119	if v == nil {
14120		return graphql.Null
14121	}
14122	return ec.marshalOInt2int(ctx, sel, *v)
14123}
14124
14125func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14126	return ec._LabelChangeResult(ctx, sel, &v)
14127}
14128
14129func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14130	if v == nil {
14131		return graphql.Null
14132	}
14133	return ec._LabelChangeResult(ctx, sel, v)
14134}
14135
14136func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14137	return ec._Repository(ctx, sel, &v)
14138}
14139
14140func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14141	if v == nil {
14142		return graphql.Null
14143	}
14144	return ec._Repository(ctx, sel, v)
14145}
14146
14147func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14148	return graphql.UnmarshalString(v)
14149}
14150
14151func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14152	return graphql.MarshalString(v)
14153}
14154
14155func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14156	var vSlice []interface{}
14157	if v != nil {
14158		if tmp1, ok := v.([]interface{}); ok {
14159			vSlice = tmp1
14160		} else {
14161			vSlice = []interface{}{v}
14162		}
14163	}
14164	var err error
14165	res := make([]string, len(vSlice))
14166	for i := range vSlice {
14167		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14168		if err != nil {
14169			return nil, err
14170		}
14171	}
14172	return res, nil
14173}
14174
14175func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14176	if v == nil {
14177		return graphql.Null
14178	}
14179	ret := make(graphql.Array, len(v))
14180	for i := range v {
14181		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14182	}
14183
14184	return ret
14185}
14186
14187func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14188	if v == nil {
14189		return nil, nil
14190	}
14191	res, err := ec.unmarshalOString2string(ctx, v)
14192	return &res, err
14193}
14194
14195func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14196	if v == nil {
14197		return graphql.Null
14198	}
14199	return ec.marshalOString2string(ctx, sel, *v)
14200}
14201
14202func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14203	if v == nil {
14204		return graphql.Null
14205	}
14206	ret := make(graphql.Array, len(v))
14207	var wg sync.WaitGroup
14208	isLen1 := len(v) == 1
14209	if !isLen1 {
14210		wg.Add(len(v))
14211	}
14212	for i := range v {
14213		i := i
14214		fc := &graphql.FieldContext{
14215			Index:  &i,
14216			Result: &v[i],
14217		}
14218		ctx := graphql.WithFieldContext(ctx, fc)
14219		f := func(i int) {
14220			defer func() {
14221				if r := recover(); r != nil {
14222					ec.Error(ctx, ec.Recover(ctx, r))
14223					ret = nil
14224				}
14225			}()
14226			if !isLen1 {
14227				defer wg.Done()
14228			}
14229			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14230		}
14231		if isLen1 {
14232			f(i)
14233		} else {
14234			go f(i)
14235		}
14236
14237	}
14238	wg.Wait()
14239	return ret
14240}
14241
14242func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14243	if v == nil {
14244		return graphql.Null
14245	}
14246	ret := make(graphql.Array, len(v))
14247	var wg sync.WaitGroup
14248	isLen1 := len(v) == 1
14249	if !isLen1 {
14250		wg.Add(len(v))
14251	}
14252	for i := range v {
14253		i := i
14254		fc := &graphql.FieldContext{
14255			Index:  &i,
14256			Result: &v[i],
14257		}
14258		ctx := graphql.WithFieldContext(ctx, fc)
14259		f := func(i int) {
14260			defer func() {
14261				if r := recover(); r != nil {
14262					ec.Error(ctx, ec.Recover(ctx, r))
14263					ret = nil
14264				}
14265			}()
14266			if !isLen1 {
14267				defer wg.Done()
14268			}
14269			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14270		}
14271		if isLen1 {
14272			f(i)
14273		} else {
14274			go f(i)
14275		}
14276
14277	}
14278	wg.Wait()
14279	return ret
14280}
14281
14282func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14283	if v == nil {
14284		return graphql.Null
14285	}
14286	ret := make(graphql.Array, len(v))
14287	var wg sync.WaitGroup
14288	isLen1 := len(v) == 1
14289	if !isLen1 {
14290		wg.Add(len(v))
14291	}
14292	for i := range v {
14293		i := i
14294		fc := &graphql.FieldContext{
14295			Index:  &i,
14296			Result: &v[i],
14297		}
14298		ctx := graphql.WithFieldContext(ctx, fc)
14299		f := func(i int) {
14300			defer func() {
14301				if r := recover(); r != nil {
14302					ec.Error(ctx, ec.Recover(ctx, r))
14303					ret = nil
14304				}
14305			}()
14306			if !isLen1 {
14307				defer wg.Done()
14308			}
14309			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14310		}
14311		if isLen1 {
14312			f(i)
14313		} else {
14314			go f(i)
14315		}
14316
14317	}
14318	wg.Wait()
14319	return ret
14320}
14321
14322func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14323	return ec.___Schema(ctx, sel, &v)
14324}
14325
14326func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14327	if v == nil {
14328		return graphql.Null
14329	}
14330	return ec.___Schema(ctx, sel, v)
14331}
14332
14333func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14334	return ec.___Type(ctx, sel, &v)
14335}
14336
14337func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14338	if v == nil {
14339		return graphql.Null
14340	}
14341	ret := make(graphql.Array, len(v))
14342	var wg sync.WaitGroup
14343	isLen1 := len(v) == 1
14344	if !isLen1 {
14345		wg.Add(len(v))
14346	}
14347	for i := range v {
14348		i := i
14349		fc := &graphql.FieldContext{
14350			Index:  &i,
14351			Result: &v[i],
14352		}
14353		ctx := graphql.WithFieldContext(ctx, fc)
14354		f := func(i int) {
14355			defer func() {
14356				if r := recover(); r != nil {
14357					ec.Error(ctx, ec.Recover(ctx, r))
14358					ret = nil
14359				}
14360			}()
14361			if !isLen1 {
14362				defer wg.Done()
14363			}
14364			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14365		}
14366		if isLen1 {
14367			f(i)
14368		} else {
14369			go f(i)
14370		}
14371
14372	}
14373	wg.Wait()
14374	return ret
14375}
14376
14377func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14378	if v == nil {
14379		return graphql.Null
14380	}
14381	return ec.___Type(ctx, sel, v)
14382}
14383
14384// endregion ***************************** type.gotpl *****************************