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/api/graphql/models"
   19	"github.com/MichaelMure/git-bug/bug"
   20	"github.com/MichaelMure/git-bug/repository"
   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	EditCommentPayload struct {
  197		Bug              func(childComplexity int) int
  198		ClientMutationID func(childComplexity int) int
  199		Operation        func(childComplexity int) int
  200	}
  201
  202	Identity struct {
  203		AvatarUrl   func(childComplexity int) int
  204		DisplayName func(childComplexity int) int
  205		Email       func(childComplexity int) int
  206		HumanID     func(childComplexity int) int
  207		ID          func(childComplexity int) int
  208		IsProtected func(childComplexity int) int
  209		Login       func(childComplexity int) int
  210		Name        func(childComplexity int) int
  211	}
  212
  213	IdentityConnection struct {
  214		Edges      func(childComplexity int) int
  215		Nodes      func(childComplexity int) int
  216		PageInfo   func(childComplexity int) int
  217		TotalCount func(childComplexity int) int
  218	}
  219
  220	IdentityEdge struct {
  221		Cursor func(childComplexity int) int
  222		Node   func(childComplexity int) int
  223	}
  224
  225	Label struct {
  226		Color func(childComplexity int) int
  227		Name  func(childComplexity int) int
  228	}
  229
  230	LabelChangeOperation struct {
  231		Added   func(childComplexity int) int
  232		Author  func(childComplexity int) int
  233		Date    func(childComplexity int) int
  234		ID      func(childComplexity int) int
  235		Removed func(childComplexity int) int
  236	}
  237
  238	LabelChangeResult struct {
  239		Label  func(childComplexity int) int
  240		Status func(childComplexity int) int
  241	}
  242
  243	LabelChangeTimelineItem struct {
  244		Added   func(childComplexity int) int
  245		Author  func(childComplexity int) int
  246		Date    func(childComplexity int) int
  247		ID      func(childComplexity int) int
  248		Removed func(childComplexity int) int
  249	}
  250
  251	LabelConnection struct {
  252		Edges      func(childComplexity int) int
  253		Nodes      func(childComplexity int) int
  254		PageInfo   func(childComplexity int) int
  255		TotalCount func(childComplexity int) int
  256	}
  257
  258	LabelEdge struct {
  259		Cursor func(childComplexity int) int
  260		Node   func(childComplexity int) int
  261	}
  262
  263	Mutation struct {
  264		AddComment   func(childComplexity int, input models.AddCommentInput) int
  265		ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
  266		CloseBug     func(childComplexity int, input models.CloseBugInput) int
  267		EditComment  func(childComplexity int, input models.EditCommentInput) int
  268		NewBug       func(childComplexity int, input models.NewBugInput) int
  269		OpenBug      func(childComplexity int, input models.OpenBugInput) int
  270		SetTitle     func(childComplexity int, input models.SetTitleInput) int
  271	}
  272
  273	NewBugPayload struct {
  274		Bug              func(childComplexity int) int
  275		ClientMutationID func(childComplexity int) int
  276		Operation        func(childComplexity int) int
  277	}
  278
  279	OpenBugPayload struct {
  280		Bug              func(childComplexity int) int
  281		ClientMutationID func(childComplexity int) int
  282		Operation        func(childComplexity int) int
  283	}
  284
  285	OperationConnection struct {
  286		Edges      func(childComplexity int) int
  287		Nodes      func(childComplexity int) int
  288		PageInfo   func(childComplexity int) int
  289		TotalCount func(childComplexity int) int
  290	}
  291
  292	OperationEdge struct {
  293		Cursor func(childComplexity int) int
  294		Node   func(childComplexity int) int
  295	}
  296
  297	PageInfo struct {
  298		EndCursor       func(childComplexity int) int
  299		HasNextPage     func(childComplexity int) int
  300		HasPreviousPage func(childComplexity int) int
  301		StartCursor     func(childComplexity int) int
  302	}
  303
  304	Query struct {
  305		Repository func(childComplexity int, ref *string) int
  306	}
  307
  308	Repository struct {
  309		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  310		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  311		Bug           func(childComplexity int, prefix string) int
  312		Identity      func(childComplexity int, prefix string) int
  313		Name          func(childComplexity int) int
  314		UserIdentity  func(childComplexity int) int
  315		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  316	}
  317
  318	SetStatusOperation struct {
  319		Author func(childComplexity int) int
  320		Date   func(childComplexity int) int
  321		ID     func(childComplexity int) int
  322		Status func(childComplexity int) int
  323	}
  324
  325	SetStatusTimelineItem struct {
  326		Author func(childComplexity int) int
  327		Date   func(childComplexity int) int
  328		ID     func(childComplexity int) int
  329		Status func(childComplexity int) int
  330	}
  331
  332	SetTitleOperation struct {
  333		Author func(childComplexity int) int
  334		Date   func(childComplexity int) int
  335		ID     func(childComplexity int) int
  336		Title  func(childComplexity int) int
  337		Was    func(childComplexity int) int
  338	}
  339
  340	SetTitlePayload struct {
  341		Bug              func(childComplexity int) int
  342		ClientMutationID func(childComplexity int) int
  343		Operation        func(childComplexity int) int
  344	}
  345
  346	SetTitleTimelineItem struct {
  347		Author func(childComplexity int) int
  348		Date   func(childComplexity int) int
  349		ID     func(childComplexity int) int
  350		Title  func(childComplexity int) int
  351		Was    func(childComplexity int) int
  352	}
  353
  354	TimelineItemConnection struct {
  355		Edges      func(childComplexity int) int
  356		Nodes      func(childComplexity int) int
  357		PageInfo   func(childComplexity int) int
  358		TotalCount func(childComplexity int) int
  359	}
  360
  361	TimelineItemEdge struct {
  362		Cursor func(childComplexity int) int
  363		Node   func(childComplexity int) int
  364	}
  365}
  366
  367type AddCommentOperationResolver interface {
  368	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  369	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
  370	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  371}
  372type AddCommentTimelineItemResolver interface {
  373	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  374	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
  375
  376	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  377	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  378}
  379type BugResolver interface {
  380	ID(ctx context.Context, obj models.BugWrapper) (string, error)
  381	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  382	Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
  383
  384	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  385	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  386	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  387	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  388	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  389}
  390type ColorResolver interface {
  391	R(ctx context.Context, obj *color.RGBA) (int, error)
  392	G(ctx context.Context, obj *color.RGBA) (int, error)
  393	B(ctx context.Context, obj *color.RGBA) (int, error)
  394}
  395type CommentResolver interface {
  396	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
  397}
  398type CommentHistoryStepResolver interface {
  399	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  400}
  401type CreateOperationResolver interface {
  402	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  403	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
  404	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  405}
  406type CreateTimelineItemResolver interface {
  407	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  408	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
  409
  410	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  411	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  412}
  413type EditCommentOperationResolver interface {
  414	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  415	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
  416	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  417	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  418}
  419type IdentityResolver interface {
  420	ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  421	HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  422}
  423type LabelResolver interface {
  424	Name(ctx context.Context, obj *bug.Label) (string, error)
  425	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  426}
  427type LabelChangeOperationResolver interface {
  428	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  429	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
  430	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  431}
  432type LabelChangeResultResolver interface {
  433	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  434}
  435type LabelChangeTimelineItemResolver interface {
  436	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  437	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
  438	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  439}
  440type MutationResolver interface {
  441	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  442	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  443	EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
  444	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  445	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  446	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  447	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  448}
  449type QueryResolver interface {
  450	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  451}
  452type RepositoryResolver interface {
  453	Name(ctx context.Context, obj *models.Repository) (*string, error)
  454	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  455	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  456	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  457	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  458	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  459	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  460}
  461type SetStatusOperationResolver interface {
  462	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  463	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
  464	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  465	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  466}
  467type SetStatusTimelineItemResolver interface {
  468	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  469	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
  470	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  471	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  472}
  473type SetTitleOperationResolver interface {
  474	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  475	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
  476	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  477}
  478type SetTitleTimelineItemResolver interface {
  479	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  480	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
  481	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  482}
  483
  484type executableSchema struct {
  485	resolvers  ResolverRoot
  486	directives DirectiveRoot
  487	complexity ComplexityRoot
  488}
  489
  490func (e *executableSchema) Schema() *ast.Schema {
  491	return parsedSchema
  492}
  493
  494func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  495	ec := executionContext{nil, e}
  496	_ = ec
  497	switch typeName + "." + field {
  498
  499	case "AddCommentOperation.author":
  500		if e.complexity.AddCommentOperation.Author == nil {
  501			break
  502		}
  503
  504		return e.complexity.AddCommentOperation.Author(childComplexity), true
  505
  506	case "AddCommentOperation.date":
  507		if e.complexity.AddCommentOperation.Date == nil {
  508			break
  509		}
  510
  511		return e.complexity.AddCommentOperation.Date(childComplexity), true
  512
  513	case "AddCommentOperation.files":
  514		if e.complexity.AddCommentOperation.Files == nil {
  515			break
  516		}
  517
  518		return e.complexity.AddCommentOperation.Files(childComplexity), true
  519
  520	case "AddCommentOperation.id":
  521		if e.complexity.AddCommentOperation.ID == nil {
  522			break
  523		}
  524
  525		return e.complexity.AddCommentOperation.ID(childComplexity), true
  526
  527	case "AddCommentOperation.message":
  528		if e.complexity.AddCommentOperation.Message == nil {
  529			break
  530		}
  531
  532		return e.complexity.AddCommentOperation.Message(childComplexity), true
  533
  534	case "AddCommentPayload.bug":
  535		if e.complexity.AddCommentPayload.Bug == nil {
  536			break
  537		}
  538
  539		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  540
  541	case "AddCommentPayload.clientMutationId":
  542		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  543			break
  544		}
  545
  546		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  547
  548	case "AddCommentPayload.operation":
  549		if e.complexity.AddCommentPayload.Operation == nil {
  550			break
  551		}
  552
  553		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  554
  555	case "AddCommentTimelineItem.author":
  556		if e.complexity.AddCommentTimelineItem.Author == nil {
  557			break
  558		}
  559
  560		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  561
  562	case "AddCommentTimelineItem.createdAt":
  563		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  564			break
  565		}
  566
  567		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  568
  569	case "AddCommentTimelineItem.edited":
  570		if e.complexity.AddCommentTimelineItem.Edited == nil {
  571			break
  572		}
  573
  574		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  575
  576	case "AddCommentTimelineItem.files":
  577		if e.complexity.AddCommentTimelineItem.Files == nil {
  578			break
  579		}
  580
  581		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  582
  583	case "AddCommentTimelineItem.history":
  584		if e.complexity.AddCommentTimelineItem.History == nil {
  585			break
  586		}
  587
  588		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  589
  590	case "AddCommentTimelineItem.id":
  591		if e.complexity.AddCommentTimelineItem.ID == nil {
  592			break
  593		}
  594
  595		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  596
  597	case "AddCommentTimelineItem.lastEdit":
  598		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  599			break
  600		}
  601
  602		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  603
  604	case "AddCommentTimelineItem.message":
  605		if e.complexity.AddCommentTimelineItem.Message == nil {
  606			break
  607		}
  608
  609		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  610
  611	case "AddCommentTimelineItem.messageIsEmpty":
  612		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  613			break
  614		}
  615
  616		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  617
  618	case "Bug.actors":
  619		if e.complexity.Bug.Actors == nil {
  620			break
  621		}
  622
  623		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  624		if err != nil {
  625			return 0, false
  626		}
  627
  628		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  629
  630	case "Bug.author":
  631		if e.complexity.Bug.Author == nil {
  632			break
  633		}
  634
  635		return e.complexity.Bug.Author(childComplexity), true
  636
  637	case "Bug.comments":
  638		if e.complexity.Bug.Comments == nil {
  639			break
  640		}
  641
  642		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  643		if err != nil {
  644			return 0, false
  645		}
  646
  647		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  648
  649	case "Bug.createdAt":
  650		if e.complexity.Bug.CreatedAt == nil {
  651			break
  652		}
  653
  654		return e.complexity.Bug.CreatedAt(childComplexity), true
  655
  656	case "Bug.humanId":
  657		if e.complexity.Bug.HumanID == nil {
  658			break
  659		}
  660
  661		return e.complexity.Bug.HumanID(childComplexity), true
  662
  663	case "Bug.id":
  664		if e.complexity.Bug.ID == nil {
  665			break
  666		}
  667
  668		return e.complexity.Bug.ID(childComplexity), true
  669
  670	case "Bug.labels":
  671		if e.complexity.Bug.Labels == nil {
  672			break
  673		}
  674
  675		return e.complexity.Bug.Labels(childComplexity), true
  676
  677	case "Bug.lastEdit":
  678		if e.complexity.Bug.LastEdit == nil {
  679			break
  680		}
  681
  682		return e.complexity.Bug.LastEdit(childComplexity), true
  683
  684	case "Bug.operations":
  685		if e.complexity.Bug.Operations == nil {
  686			break
  687		}
  688
  689		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  690		if err != nil {
  691			return 0, false
  692		}
  693
  694		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  695
  696	case "Bug.participants":
  697		if e.complexity.Bug.Participants == nil {
  698			break
  699		}
  700
  701		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  702		if err != nil {
  703			return 0, false
  704		}
  705
  706		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  707
  708	case "Bug.status":
  709		if e.complexity.Bug.Status == nil {
  710			break
  711		}
  712
  713		return e.complexity.Bug.Status(childComplexity), true
  714
  715	case "Bug.timeline":
  716		if e.complexity.Bug.Timeline == nil {
  717			break
  718		}
  719
  720		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  721		if err != nil {
  722			return 0, false
  723		}
  724
  725		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  726
  727	case "Bug.title":
  728		if e.complexity.Bug.Title == nil {
  729			break
  730		}
  731
  732		return e.complexity.Bug.Title(childComplexity), true
  733
  734	case "BugConnection.edges":
  735		if e.complexity.BugConnection.Edges == nil {
  736			break
  737		}
  738
  739		return e.complexity.BugConnection.Edges(childComplexity), true
  740
  741	case "BugConnection.nodes":
  742		if e.complexity.BugConnection.Nodes == nil {
  743			break
  744		}
  745
  746		return e.complexity.BugConnection.Nodes(childComplexity), true
  747
  748	case "BugConnection.pageInfo":
  749		if e.complexity.BugConnection.PageInfo == nil {
  750			break
  751		}
  752
  753		return e.complexity.BugConnection.PageInfo(childComplexity), true
  754
  755	case "BugConnection.totalCount":
  756		if e.complexity.BugConnection.TotalCount == nil {
  757			break
  758		}
  759
  760		return e.complexity.BugConnection.TotalCount(childComplexity), true
  761
  762	case "BugEdge.cursor":
  763		if e.complexity.BugEdge.Cursor == nil {
  764			break
  765		}
  766
  767		return e.complexity.BugEdge.Cursor(childComplexity), true
  768
  769	case "BugEdge.node":
  770		if e.complexity.BugEdge.Node == nil {
  771			break
  772		}
  773
  774		return e.complexity.BugEdge.Node(childComplexity), true
  775
  776	case "ChangeLabelPayload.bug":
  777		if e.complexity.ChangeLabelPayload.Bug == nil {
  778			break
  779		}
  780
  781		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  782
  783	case "ChangeLabelPayload.clientMutationId":
  784		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  785			break
  786		}
  787
  788		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  789
  790	case "ChangeLabelPayload.operation":
  791		if e.complexity.ChangeLabelPayload.Operation == nil {
  792			break
  793		}
  794
  795		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  796
  797	case "ChangeLabelPayload.results":
  798		if e.complexity.ChangeLabelPayload.Results == nil {
  799			break
  800		}
  801
  802		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  803
  804	case "CloseBugPayload.bug":
  805		if e.complexity.CloseBugPayload.Bug == nil {
  806			break
  807		}
  808
  809		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  810
  811	case "CloseBugPayload.clientMutationId":
  812		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  813			break
  814		}
  815
  816		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  817
  818	case "CloseBugPayload.operation":
  819		if e.complexity.CloseBugPayload.Operation == nil {
  820			break
  821		}
  822
  823		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  824
  825	case "Color.B":
  826		if e.complexity.Color.B == nil {
  827			break
  828		}
  829
  830		return e.complexity.Color.B(childComplexity), true
  831
  832	case "Color.G":
  833		if e.complexity.Color.G == nil {
  834			break
  835		}
  836
  837		return e.complexity.Color.G(childComplexity), true
  838
  839	case "Color.R":
  840		if e.complexity.Color.R == nil {
  841			break
  842		}
  843
  844		return e.complexity.Color.R(childComplexity), true
  845
  846	case "Comment.author":
  847		if e.complexity.Comment.Author == nil {
  848			break
  849		}
  850
  851		return e.complexity.Comment.Author(childComplexity), true
  852
  853	case "Comment.files":
  854		if e.complexity.Comment.Files == nil {
  855			break
  856		}
  857
  858		return e.complexity.Comment.Files(childComplexity), true
  859
  860	case "Comment.message":
  861		if e.complexity.Comment.Message == nil {
  862			break
  863		}
  864
  865		return e.complexity.Comment.Message(childComplexity), true
  866
  867	case "CommentConnection.edges":
  868		if e.complexity.CommentConnection.Edges == nil {
  869			break
  870		}
  871
  872		return e.complexity.CommentConnection.Edges(childComplexity), true
  873
  874	case "CommentConnection.nodes":
  875		if e.complexity.CommentConnection.Nodes == nil {
  876			break
  877		}
  878
  879		return e.complexity.CommentConnection.Nodes(childComplexity), true
  880
  881	case "CommentConnection.pageInfo":
  882		if e.complexity.CommentConnection.PageInfo == nil {
  883			break
  884		}
  885
  886		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  887
  888	case "CommentConnection.totalCount":
  889		if e.complexity.CommentConnection.TotalCount == nil {
  890			break
  891		}
  892
  893		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  894
  895	case "CommentEdge.cursor":
  896		if e.complexity.CommentEdge.Cursor == nil {
  897			break
  898		}
  899
  900		return e.complexity.CommentEdge.Cursor(childComplexity), true
  901
  902	case "CommentEdge.node":
  903		if e.complexity.CommentEdge.Node == nil {
  904			break
  905		}
  906
  907		return e.complexity.CommentEdge.Node(childComplexity), true
  908
  909	case "CommentHistoryStep.date":
  910		if e.complexity.CommentHistoryStep.Date == nil {
  911			break
  912		}
  913
  914		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  915
  916	case "CommentHistoryStep.message":
  917		if e.complexity.CommentHistoryStep.Message == nil {
  918			break
  919		}
  920
  921		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  922
  923	case "CreateOperation.author":
  924		if e.complexity.CreateOperation.Author == nil {
  925			break
  926		}
  927
  928		return e.complexity.CreateOperation.Author(childComplexity), true
  929
  930	case "CreateOperation.date":
  931		if e.complexity.CreateOperation.Date == nil {
  932			break
  933		}
  934
  935		return e.complexity.CreateOperation.Date(childComplexity), true
  936
  937	case "CreateOperation.files":
  938		if e.complexity.CreateOperation.Files == nil {
  939			break
  940		}
  941
  942		return e.complexity.CreateOperation.Files(childComplexity), true
  943
  944	case "CreateOperation.id":
  945		if e.complexity.CreateOperation.ID == nil {
  946			break
  947		}
  948
  949		return e.complexity.CreateOperation.ID(childComplexity), true
  950
  951	case "CreateOperation.message":
  952		if e.complexity.CreateOperation.Message == nil {
  953			break
  954		}
  955
  956		return e.complexity.CreateOperation.Message(childComplexity), true
  957
  958	case "CreateOperation.title":
  959		if e.complexity.CreateOperation.Title == nil {
  960			break
  961		}
  962
  963		return e.complexity.CreateOperation.Title(childComplexity), true
  964
  965	case "CreateTimelineItem.author":
  966		if e.complexity.CreateTimelineItem.Author == nil {
  967			break
  968		}
  969
  970		return e.complexity.CreateTimelineItem.Author(childComplexity), true
  971
  972	case "CreateTimelineItem.createdAt":
  973		if e.complexity.CreateTimelineItem.CreatedAt == nil {
  974			break
  975		}
  976
  977		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
  978
  979	case "CreateTimelineItem.edited":
  980		if e.complexity.CreateTimelineItem.Edited == nil {
  981			break
  982		}
  983
  984		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
  985
  986	case "CreateTimelineItem.files":
  987		if e.complexity.CreateTimelineItem.Files == nil {
  988			break
  989		}
  990
  991		return e.complexity.CreateTimelineItem.Files(childComplexity), true
  992
  993	case "CreateTimelineItem.history":
  994		if e.complexity.CreateTimelineItem.History == nil {
  995			break
  996		}
  997
  998		return e.complexity.CreateTimelineItem.History(childComplexity), true
  999
 1000	case "CreateTimelineItem.id":
 1001		if e.complexity.CreateTimelineItem.ID == nil {
 1002			break
 1003		}
 1004
 1005		return e.complexity.CreateTimelineItem.ID(childComplexity), true
 1006
 1007	case "CreateTimelineItem.lastEdit":
 1008		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1009			break
 1010		}
 1011
 1012		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1013
 1014	case "CreateTimelineItem.message":
 1015		if e.complexity.CreateTimelineItem.Message == nil {
 1016			break
 1017		}
 1018
 1019		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1020
 1021	case "CreateTimelineItem.messageIsEmpty":
 1022		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1023			break
 1024		}
 1025
 1026		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1027
 1028	case "EditCommentOperation.author":
 1029		if e.complexity.EditCommentOperation.Author == nil {
 1030			break
 1031		}
 1032
 1033		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1034
 1035	case "EditCommentOperation.date":
 1036		if e.complexity.EditCommentOperation.Date == nil {
 1037			break
 1038		}
 1039
 1040		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1041
 1042	case "EditCommentOperation.files":
 1043		if e.complexity.EditCommentOperation.Files == nil {
 1044			break
 1045		}
 1046
 1047		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1048
 1049	case "EditCommentOperation.id":
 1050		if e.complexity.EditCommentOperation.ID == nil {
 1051			break
 1052		}
 1053
 1054		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1055
 1056	case "EditCommentOperation.message":
 1057		if e.complexity.EditCommentOperation.Message == nil {
 1058			break
 1059		}
 1060
 1061		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1062
 1063	case "EditCommentOperation.target":
 1064		if e.complexity.EditCommentOperation.Target == nil {
 1065			break
 1066		}
 1067
 1068		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1069
 1070	case "EditCommentPayload.bug":
 1071		if e.complexity.EditCommentPayload.Bug == nil {
 1072			break
 1073		}
 1074
 1075		return e.complexity.EditCommentPayload.Bug(childComplexity), true
 1076
 1077	case "EditCommentPayload.clientMutationId":
 1078		if e.complexity.EditCommentPayload.ClientMutationID == nil {
 1079			break
 1080		}
 1081
 1082		return e.complexity.EditCommentPayload.ClientMutationID(childComplexity), true
 1083
 1084	case "EditCommentPayload.operation":
 1085		if e.complexity.EditCommentPayload.Operation == nil {
 1086			break
 1087		}
 1088
 1089		return e.complexity.EditCommentPayload.Operation(childComplexity), true
 1090
 1091	case "Identity.avatarUrl":
 1092		if e.complexity.Identity.AvatarUrl == nil {
 1093			break
 1094		}
 1095
 1096		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1097
 1098	case "Identity.displayName":
 1099		if e.complexity.Identity.DisplayName == nil {
 1100			break
 1101		}
 1102
 1103		return e.complexity.Identity.DisplayName(childComplexity), true
 1104
 1105	case "Identity.email":
 1106		if e.complexity.Identity.Email == nil {
 1107			break
 1108		}
 1109
 1110		return e.complexity.Identity.Email(childComplexity), true
 1111
 1112	case "Identity.humanId":
 1113		if e.complexity.Identity.HumanID == nil {
 1114			break
 1115		}
 1116
 1117		return e.complexity.Identity.HumanID(childComplexity), true
 1118
 1119	case "Identity.id":
 1120		if e.complexity.Identity.ID == nil {
 1121			break
 1122		}
 1123
 1124		return e.complexity.Identity.ID(childComplexity), true
 1125
 1126	case "Identity.isProtected":
 1127		if e.complexity.Identity.IsProtected == nil {
 1128			break
 1129		}
 1130
 1131		return e.complexity.Identity.IsProtected(childComplexity), true
 1132
 1133	case "Identity.login":
 1134		if e.complexity.Identity.Login == nil {
 1135			break
 1136		}
 1137
 1138		return e.complexity.Identity.Login(childComplexity), true
 1139
 1140	case "Identity.name":
 1141		if e.complexity.Identity.Name == nil {
 1142			break
 1143		}
 1144
 1145		return e.complexity.Identity.Name(childComplexity), true
 1146
 1147	case "IdentityConnection.edges":
 1148		if e.complexity.IdentityConnection.Edges == nil {
 1149			break
 1150		}
 1151
 1152		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1153
 1154	case "IdentityConnection.nodes":
 1155		if e.complexity.IdentityConnection.Nodes == nil {
 1156			break
 1157		}
 1158
 1159		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1160
 1161	case "IdentityConnection.pageInfo":
 1162		if e.complexity.IdentityConnection.PageInfo == nil {
 1163			break
 1164		}
 1165
 1166		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1167
 1168	case "IdentityConnection.totalCount":
 1169		if e.complexity.IdentityConnection.TotalCount == nil {
 1170			break
 1171		}
 1172
 1173		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1174
 1175	case "IdentityEdge.cursor":
 1176		if e.complexity.IdentityEdge.Cursor == nil {
 1177			break
 1178		}
 1179
 1180		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1181
 1182	case "IdentityEdge.node":
 1183		if e.complexity.IdentityEdge.Node == nil {
 1184			break
 1185		}
 1186
 1187		return e.complexity.IdentityEdge.Node(childComplexity), true
 1188
 1189	case "Label.color":
 1190		if e.complexity.Label.Color == nil {
 1191			break
 1192		}
 1193
 1194		return e.complexity.Label.Color(childComplexity), true
 1195
 1196	case "Label.name":
 1197		if e.complexity.Label.Name == nil {
 1198			break
 1199		}
 1200
 1201		return e.complexity.Label.Name(childComplexity), true
 1202
 1203	case "LabelChangeOperation.added":
 1204		if e.complexity.LabelChangeOperation.Added == nil {
 1205			break
 1206		}
 1207
 1208		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1209
 1210	case "LabelChangeOperation.author":
 1211		if e.complexity.LabelChangeOperation.Author == nil {
 1212			break
 1213		}
 1214
 1215		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1216
 1217	case "LabelChangeOperation.date":
 1218		if e.complexity.LabelChangeOperation.Date == nil {
 1219			break
 1220		}
 1221
 1222		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1223
 1224	case "LabelChangeOperation.id":
 1225		if e.complexity.LabelChangeOperation.ID == nil {
 1226			break
 1227		}
 1228
 1229		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1230
 1231	case "LabelChangeOperation.removed":
 1232		if e.complexity.LabelChangeOperation.Removed == nil {
 1233			break
 1234		}
 1235
 1236		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1237
 1238	case "LabelChangeResult.label":
 1239		if e.complexity.LabelChangeResult.Label == nil {
 1240			break
 1241		}
 1242
 1243		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1244
 1245	case "LabelChangeResult.status":
 1246		if e.complexity.LabelChangeResult.Status == nil {
 1247			break
 1248		}
 1249
 1250		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1251
 1252	case "LabelChangeTimelineItem.added":
 1253		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1254			break
 1255		}
 1256
 1257		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1258
 1259	case "LabelChangeTimelineItem.author":
 1260		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1261			break
 1262		}
 1263
 1264		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1265
 1266	case "LabelChangeTimelineItem.date":
 1267		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1268			break
 1269		}
 1270
 1271		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1272
 1273	case "LabelChangeTimelineItem.id":
 1274		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1275			break
 1276		}
 1277
 1278		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1279
 1280	case "LabelChangeTimelineItem.removed":
 1281		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1282			break
 1283		}
 1284
 1285		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1286
 1287	case "LabelConnection.edges":
 1288		if e.complexity.LabelConnection.Edges == nil {
 1289			break
 1290		}
 1291
 1292		return e.complexity.LabelConnection.Edges(childComplexity), true
 1293
 1294	case "LabelConnection.nodes":
 1295		if e.complexity.LabelConnection.Nodes == nil {
 1296			break
 1297		}
 1298
 1299		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1300
 1301	case "LabelConnection.pageInfo":
 1302		if e.complexity.LabelConnection.PageInfo == nil {
 1303			break
 1304		}
 1305
 1306		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1307
 1308	case "LabelConnection.totalCount":
 1309		if e.complexity.LabelConnection.TotalCount == nil {
 1310			break
 1311		}
 1312
 1313		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1314
 1315	case "LabelEdge.cursor":
 1316		if e.complexity.LabelEdge.Cursor == nil {
 1317			break
 1318		}
 1319
 1320		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1321
 1322	case "LabelEdge.node":
 1323		if e.complexity.LabelEdge.Node == nil {
 1324			break
 1325		}
 1326
 1327		return e.complexity.LabelEdge.Node(childComplexity), true
 1328
 1329	case "Mutation.addComment":
 1330		if e.complexity.Mutation.AddComment == nil {
 1331			break
 1332		}
 1333
 1334		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1335		if err != nil {
 1336			return 0, false
 1337		}
 1338
 1339		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1340
 1341	case "Mutation.changeLabels":
 1342		if e.complexity.Mutation.ChangeLabels == nil {
 1343			break
 1344		}
 1345
 1346		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1347		if err != nil {
 1348			return 0, false
 1349		}
 1350
 1351		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1352
 1353	case "Mutation.closeBug":
 1354		if e.complexity.Mutation.CloseBug == nil {
 1355			break
 1356		}
 1357
 1358		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1359		if err != nil {
 1360			return 0, false
 1361		}
 1362
 1363		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1364
 1365	case "Mutation.editComment":
 1366		if e.complexity.Mutation.EditComment == nil {
 1367			break
 1368		}
 1369
 1370		args, err := ec.field_Mutation_editComment_args(context.TODO(), rawArgs)
 1371		if err != nil {
 1372			return 0, false
 1373		}
 1374
 1375		return e.complexity.Mutation.EditComment(childComplexity, args["input"].(models.EditCommentInput)), true
 1376
 1377	case "Mutation.newBug":
 1378		if e.complexity.Mutation.NewBug == nil {
 1379			break
 1380		}
 1381
 1382		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1383		if err != nil {
 1384			return 0, false
 1385		}
 1386
 1387		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1388
 1389	case "Mutation.openBug":
 1390		if e.complexity.Mutation.OpenBug == nil {
 1391			break
 1392		}
 1393
 1394		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1395		if err != nil {
 1396			return 0, false
 1397		}
 1398
 1399		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1400
 1401	case "Mutation.setTitle":
 1402		if e.complexity.Mutation.SetTitle == nil {
 1403			break
 1404		}
 1405
 1406		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1407		if err != nil {
 1408			return 0, false
 1409		}
 1410
 1411		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1412
 1413	case "NewBugPayload.bug":
 1414		if e.complexity.NewBugPayload.Bug == nil {
 1415			break
 1416		}
 1417
 1418		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1419
 1420	case "NewBugPayload.clientMutationId":
 1421		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1422			break
 1423		}
 1424
 1425		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1426
 1427	case "NewBugPayload.operation":
 1428		if e.complexity.NewBugPayload.Operation == nil {
 1429			break
 1430		}
 1431
 1432		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1433
 1434	case "OpenBugPayload.bug":
 1435		if e.complexity.OpenBugPayload.Bug == nil {
 1436			break
 1437		}
 1438
 1439		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1440
 1441	case "OpenBugPayload.clientMutationId":
 1442		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1443			break
 1444		}
 1445
 1446		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1447
 1448	case "OpenBugPayload.operation":
 1449		if e.complexity.OpenBugPayload.Operation == nil {
 1450			break
 1451		}
 1452
 1453		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1454
 1455	case "OperationConnection.edges":
 1456		if e.complexity.OperationConnection.Edges == nil {
 1457			break
 1458		}
 1459
 1460		return e.complexity.OperationConnection.Edges(childComplexity), true
 1461
 1462	case "OperationConnection.nodes":
 1463		if e.complexity.OperationConnection.Nodes == nil {
 1464			break
 1465		}
 1466
 1467		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1468
 1469	case "OperationConnection.pageInfo":
 1470		if e.complexity.OperationConnection.PageInfo == nil {
 1471			break
 1472		}
 1473
 1474		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1475
 1476	case "OperationConnection.totalCount":
 1477		if e.complexity.OperationConnection.TotalCount == nil {
 1478			break
 1479		}
 1480
 1481		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1482
 1483	case "OperationEdge.cursor":
 1484		if e.complexity.OperationEdge.Cursor == nil {
 1485			break
 1486		}
 1487
 1488		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1489
 1490	case "OperationEdge.node":
 1491		if e.complexity.OperationEdge.Node == nil {
 1492			break
 1493		}
 1494
 1495		return e.complexity.OperationEdge.Node(childComplexity), true
 1496
 1497	case "PageInfo.endCursor":
 1498		if e.complexity.PageInfo.EndCursor == nil {
 1499			break
 1500		}
 1501
 1502		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1503
 1504	case "PageInfo.hasNextPage":
 1505		if e.complexity.PageInfo.HasNextPage == nil {
 1506			break
 1507		}
 1508
 1509		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1510
 1511	case "PageInfo.hasPreviousPage":
 1512		if e.complexity.PageInfo.HasPreviousPage == nil {
 1513			break
 1514		}
 1515
 1516		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1517
 1518	case "PageInfo.startCursor":
 1519		if e.complexity.PageInfo.StartCursor == nil {
 1520			break
 1521		}
 1522
 1523		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1524
 1525	case "Query.repository":
 1526		if e.complexity.Query.Repository == nil {
 1527			break
 1528		}
 1529
 1530		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1531		if err != nil {
 1532			return 0, false
 1533		}
 1534
 1535		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 1536
 1537	case "Repository.allBugs":
 1538		if e.complexity.Repository.AllBugs == nil {
 1539			break
 1540		}
 1541
 1542		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1543		if err != nil {
 1544			return 0, false
 1545		}
 1546
 1547		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1548
 1549	case "Repository.allIdentities":
 1550		if e.complexity.Repository.AllIdentities == nil {
 1551			break
 1552		}
 1553
 1554		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1555		if err != nil {
 1556			return 0, false
 1557		}
 1558
 1559		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1560
 1561	case "Repository.bug":
 1562		if e.complexity.Repository.Bug == nil {
 1563			break
 1564		}
 1565
 1566		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1567		if err != nil {
 1568			return 0, false
 1569		}
 1570
 1571		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1572
 1573	case "Repository.identity":
 1574		if e.complexity.Repository.Identity == nil {
 1575			break
 1576		}
 1577
 1578		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1579		if err != nil {
 1580			return 0, false
 1581		}
 1582
 1583		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1584
 1585	case "Repository.name":
 1586		if e.complexity.Repository.Name == nil {
 1587			break
 1588		}
 1589
 1590		return e.complexity.Repository.Name(childComplexity), true
 1591
 1592	case "Repository.userIdentity":
 1593		if e.complexity.Repository.UserIdentity == nil {
 1594			break
 1595		}
 1596
 1597		return e.complexity.Repository.UserIdentity(childComplexity), true
 1598
 1599	case "Repository.validLabels":
 1600		if e.complexity.Repository.ValidLabels == nil {
 1601			break
 1602		}
 1603
 1604		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1605		if err != nil {
 1606			return 0, false
 1607		}
 1608
 1609		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1610
 1611	case "SetStatusOperation.author":
 1612		if e.complexity.SetStatusOperation.Author == nil {
 1613			break
 1614		}
 1615
 1616		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1617
 1618	case "SetStatusOperation.date":
 1619		if e.complexity.SetStatusOperation.Date == nil {
 1620			break
 1621		}
 1622
 1623		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1624
 1625	case "SetStatusOperation.id":
 1626		if e.complexity.SetStatusOperation.ID == nil {
 1627			break
 1628		}
 1629
 1630		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1631
 1632	case "SetStatusOperation.status":
 1633		if e.complexity.SetStatusOperation.Status == nil {
 1634			break
 1635		}
 1636
 1637		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1638
 1639	case "SetStatusTimelineItem.author":
 1640		if e.complexity.SetStatusTimelineItem.Author == nil {
 1641			break
 1642		}
 1643
 1644		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1645
 1646	case "SetStatusTimelineItem.date":
 1647		if e.complexity.SetStatusTimelineItem.Date == nil {
 1648			break
 1649		}
 1650
 1651		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1652
 1653	case "SetStatusTimelineItem.id":
 1654		if e.complexity.SetStatusTimelineItem.ID == nil {
 1655			break
 1656		}
 1657
 1658		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1659
 1660	case "SetStatusTimelineItem.status":
 1661		if e.complexity.SetStatusTimelineItem.Status == nil {
 1662			break
 1663		}
 1664
 1665		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1666
 1667	case "SetTitleOperation.author":
 1668		if e.complexity.SetTitleOperation.Author == nil {
 1669			break
 1670		}
 1671
 1672		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1673
 1674	case "SetTitleOperation.date":
 1675		if e.complexity.SetTitleOperation.Date == nil {
 1676			break
 1677		}
 1678
 1679		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1680
 1681	case "SetTitleOperation.id":
 1682		if e.complexity.SetTitleOperation.ID == nil {
 1683			break
 1684		}
 1685
 1686		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1687
 1688	case "SetTitleOperation.title":
 1689		if e.complexity.SetTitleOperation.Title == nil {
 1690			break
 1691		}
 1692
 1693		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1694
 1695	case "SetTitleOperation.was":
 1696		if e.complexity.SetTitleOperation.Was == nil {
 1697			break
 1698		}
 1699
 1700		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1701
 1702	case "SetTitlePayload.bug":
 1703		if e.complexity.SetTitlePayload.Bug == nil {
 1704			break
 1705		}
 1706
 1707		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1708
 1709	case "SetTitlePayload.clientMutationId":
 1710		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1711			break
 1712		}
 1713
 1714		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1715
 1716	case "SetTitlePayload.operation":
 1717		if e.complexity.SetTitlePayload.Operation == nil {
 1718			break
 1719		}
 1720
 1721		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1722
 1723	case "SetTitleTimelineItem.author":
 1724		if e.complexity.SetTitleTimelineItem.Author == nil {
 1725			break
 1726		}
 1727
 1728		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1729
 1730	case "SetTitleTimelineItem.date":
 1731		if e.complexity.SetTitleTimelineItem.Date == nil {
 1732			break
 1733		}
 1734
 1735		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1736
 1737	case "SetTitleTimelineItem.id":
 1738		if e.complexity.SetTitleTimelineItem.ID == nil {
 1739			break
 1740		}
 1741
 1742		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1743
 1744	case "SetTitleTimelineItem.title":
 1745		if e.complexity.SetTitleTimelineItem.Title == nil {
 1746			break
 1747		}
 1748
 1749		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1750
 1751	case "SetTitleTimelineItem.was":
 1752		if e.complexity.SetTitleTimelineItem.Was == nil {
 1753			break
 1754		}
 1755
 1756		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1757
 1758	case "TimelineItemConnection.edges":
 1759		if e.complexity.TimelineItemConnection.Edges == nil {
 1760			break
 1761		}
 1762
 1763		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1764
 1765	case "TimelineItemConnection.nodes":
 1766		if e.complexity.TimelineItemConnection.Nodes == nil {
 1767			break
 1768		}
 1769
 1770		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1771
 1772	case "TimelineItemConnection.pageInfo":
 1773		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1774			break
 1775		}
 1776
 1777		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1778
 1779	case "TimelineItemConnection.totalCount":
 1780		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1781			break
 1782		}
 1783
 1784		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1785
 1786	case "TimelineItemEdge.cursor":
 1787		if e.complexity.TimelineItemEdge.Cursor == nil {
 1788			break
 1789		}
 1790
 1791		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1792
 1793	case "TimelineItemEdge.node":
 1794		if e.complexity.TimelineItemEdge.Node == nil {
 1795			break
 1796		}
 1797
 1798		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1799
 1800	}
 1801	return 0, false
 1802}
 1803
 1804func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1805	rc := graphql.GetOperationContext(ctx)
 1806	ec := executionContext{rc, e}
 1807	first := true
 1808
 1809	switch rc.Operation.Operation {
 1810	case ast.Query:
 1811		return func(ctx context.Context) *graphql.Response {
 1812			if !first {
 1813				return nil
 1814			}
 1815			first = false
 1816			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1817			var buf bytes.Buffer
 1818			data.MarshalGQL(&buf)
 1819
 1820			return &graphql.Response{
 1821				Data: buf.Bytes(),
 1822			}
 1823		}
 1824	case ast.Mutation:
 1825		return func(ctx context.Context) *graphql.Response {
 1826			if !first {
 1827				return nil
 1828			}
 1829			first = false
 1830			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1831			var buf bytes.Buffer
 1832			data.MarshalGQL(&buf)
 1833
 1834			return &graphql.Response{
 1835				Data: buf.Bytes(),
 1836			}
 1837		}
 1838
 1839	default:
 1840		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1841	}
 1842}
 1843
 1844type executionContext struct {
 1845	*graphql.OperationContext
 1846	*executableSchema
 1847}
 1848
 1849func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1850	if ec.DisableIntrospection {
 1851		return nil, errors.New("introspection disabled")
 1852	}
 1853	return introspection.WrapSchema(parsedSchema), nil
 1854}
 1855
 1856func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1857	if ec.DisableIntrospection {
 1858		return nil, errors.New("introspection disabled")
 1859	}
 1860	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1861}
 1862
 1863var sources = []*ast.Source{
 1864	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1865type Comment implements Authored {
 1866  """The author of this comment."""
 1867  author: Identity!
 1868
 1869  """The message of this comment."""
 1870  message: String!
 1871
 1872  """All media's hash referenced in this comment"""
 1873  files: [Hash!]!
 1874}
 1875
 1876type CommentConnection {
 1877  edges: [CommentEdge!]!
 1878  nodes: [Comment!]!
 1879  pageInfo: PageInfo!
 1880  totalCount: Int!
 1881}
 1882
 1883type CommentEdge {
 1884  cursor: String!
 1885  node: Comment!
 1886}
 1887
 1888enum Status {
 1889  OPEN
 1890  CLOSED
 1891}
 1892
 1893type Bug implements Authored {
 1894  """The identifier for this bug"""
 1895  id: String!
 1896  """The human version (truncated) identifier for this bug"""
 1897  humanId: String!
 1898  status: Status!
 1899  title: String!
 1900  labels: [Label!]!
 1901  author: Identity!
 1902  createdAt: Time!
 1903  lastEdit: Time!
 1904
 1905  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1906  actors(
 1907    """Returns the elements in the list that come after the specified cursor."""
 1908    after: String
 1909    """Returns the elements in the list that come before the specified cursor."""
 1910    before: String
 1911    """Returns the first _n_ elements from the list."""
 1912    first: Int
 1913    """Returns the last _n_ elements from the list."""
 1914    last: Int
 1915  ): IdentityConnection!
 1916
 1917  """The participants of the bug. Participants are Identity that have created or
 1918  added a comment on the bug."""
 1919  participants(
 1920    """Returns the elements in the list that come after the specified cursor."""
 1921    after: String
 1922    """Returns the elements in the list that come before the specified cursor."""
 1923    before: String
 1924    """Returns the first _n_ elements from the list."""
 1925    first: Int
 1926    """Returns the last _n_ elements from the list."""
 1927    last: Int
 1928  ): IdentityConnection!
 1929
 1930  comments(
 1931    """Returns the elements in the list that come after the specified cursor."""
 1932    after: String
 1933    """Returns the elements in the list that come before the specified cursor."""
 1934    before: String
 1935    """Returns the first _n_ elements from the list."""
 1936    first: Int
 1937    """Returns the last _n_ elements from the list."""
 1938    last: Int
 1939  ): CommentConnection!
 1940
 1941  timeline(
 1942    """Returns the elements in the list that come after the specified cursor."""
 1943    after: String
 1944    """Returns the elements in the list that come before the specified cursor."""
 1945    before: String
 1946    """Returns the first _n_ elements from the list."""
 1947    first: Int
 1948    """Returns the last _n_ elements from the list."""
 1949    last: Int
 1950  ): TimelineItemConnection!
 1951
 1952  operations(
 1953    """Returns the elements in the list that come after the specified cursor."""
 1954    after: String
 1955    """Returns the elements in the list that come before the specified cursor."""
 1956    before: String
 1957    """Returns the first _n_ elements from the list."""
 1958    first: Int
 1959    """Returns the last _n_ elements from the list."""
 1960    last: Int
 1961  ): OperationConnection!
 1962}
 1963
 1964"""The connection type for Bug."""
 1965type BugConnection {
 1966  """A list of edges."""
 1967  edges: [BugEdge!]!
 1968  nodes: [Bug!]!
 1969  """Information to aid in pagination."""
 1970  pageInfo: PageInfo!
 1971  """Identifies the total count of items in the connection."""
 1972  totalCount: Int!
 1973}
 1974
 1975"""An edge in a connection."""
 1976type BugEdge {
 1977  """A cursor for use in pagination."""
 1978  cursor: String!
 1979  """The item at the end of the edge."""
 1980  node: Bug!
 1981}
 1982`, BuiltIn: false},
 1983	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1984type Identity {
 1985    """The identifier for this identity"""
 1986    id: String!
 1987    """The human version (truncated) identifier for this identity"""
 1988    humanId: String!
 1989    """The name of the person, if known."""
 1990    name: String
 1991    """The email of the person, if known."""
 1992    email: String
 1993    """The login of the person, if known."""
 1994    login: String
 1995    """A non-empty string to display, representing the identity, based on the non-empty values."""
 1996    displayName: String!
 1997    """An url to an avatar"""
 1998    avatarUrl: String
 1999    """isProtected is true if the chain of git commits started to be signed.
 2000    If that's the case, only signed commit with a valid key for this identity can be added."""
 2001    isProtected: Boolean!
 2002}
 2003
 2004type IdentityConnection {
 2005    edges: [IdentityEdge!]!
 2006    nodes: [Identity!]!
 2007    pageInfo: PageInfo!
 2008    totalCount: Int!
 2009}
 2010
 2011type IdentityEdge {
 2012    cursor: String!
 2013    node: Identity!
 2014}`, BuiltIn: false},
 2015	&ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
 2016type Label {
 2017    """The name of the label."""
 2018    name: String!
 2019    """Color of the label."""
 2020    color: Color!
 2021}
 2022
 2023type LabelConnection {
 2024    edges: [LabelEdge!]!
 2025    nodes: [Label!]!
 2026    pageInfo: PageInfo!
 2027    totalCount: Int!
 2028}
 2029
 2030type LabelEdge {
 2031    cursor: String!
 2032    node: Label!
 2033}`, BuiltIn: false},
 2034	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 2035    """A unique identifier for the client performing the mutation."""
 2036    clientMutationId: String
 2037    """"The name of the repository. If not set, the default repository is used."""
 2038    repoRef: String
 2039    """The title of the new bug."""
 2040    title: String!
 2041    """The first message of the new bug."""
 2042    message: String!
 2043    """The collection of file's hash required for the first message."""
 2044    files: [Hash!]
 2045}
 2046
 2047type NewBugPayload {
 2048    """A unique identifier for the client performing the mutation."""
 2049    clientMutationId: String
 2050    """The created bug."""
 2051    bug: Bug!
 2052    """The resulting operation."""
 2053    operation: CreateOperation!
 2054}
 2055
 2056input AddCommentInput {
 2057    """A unique identifier for the client performing the mutation."""
 2058    clientMutationId: String
 2059    """"The name of the repository. If not set, the default repository is used."""
 2060    repoRef: String
 2061    """The bug ID's prefix."""
 2062    prefix: String!
 2063    """The first message of the new bug."""
 2064    message: String!
 2065    """The collection of file's hash required for the first message."""
 2066    files: [Hash!]
 2067}
 2068
 2069type AddCommentPayload {
 2070    """A unique identifier for the client performing the mutation."""
 2071    clientMutationId: String
 2072    """The affected bug."""
 2073    bug: Bug!
 2074    """The resulting operation."""
 2075    operation: AddCommentOperation!
 2076}
 2077
 2078input EditCommentInput {
 2079    """A unique identifier for the client performing the mutation."""
 2080    clientMutationId: String
 2081    """"The name of the repository. If not set, the default repository is used."""
 2082    repoRef: String
 2083    """The bug ID's prefix."""
 2084    prefix: String!
 2085    """The target."""
 2086    target: String!
 2087    """The new message to be set."""
 2088    message: String!
 2089    """The collection of file's hash required for the first message."""
 2090    files: [Hash!]
 2091}
 2092
 2093type EditCommentPayload {
 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: EditCommentOperation!
 2100}
 2101
 2102input ChangeLabelInput {
 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 list of label to add."""
 2110    added: [String!]
 2111    """The list of label to remove."""
 2112    Removed: [String!]
 2113}
 2114
 2115enum LabelChangeStatus {
 2116    ADDED
 2117    REMOVED
 2118    DUPLICATE_IN_OP
 2119    ALREADY_EXIST
 2120    DOESNT_EXIST
 2121}
 2122
 2123type LabelChangeResult {
 2124    """The source label."""
 2125    label: Label!
 2126    """The effect this label had."""
 2127    status: LabelChangeStatus!
 2128}
 2129
 2130type ChangeLabelPayload {
 2131    """A unique identifier for the client performing the mutation."""
 2132    clientMutationId: String
 2133    """The affected bug."""
 2134    bug: Bug!
 2135    """The resulting operation."""
 2136    operation: LabelChangeOperation!
 2137    """The effect each source label had."""
 2138    results: [LabelChangeResult]!
 2139}
 2140
 2141input OpenBugInput {
 2142    """A unique identifier for the client performing the mutation."""
 2143    clientMutationId: String
 2144    """"The name of the repository. If not set, the default repository is used."""
 2145    repoRef: String
 2146    """The bug ID's prefix."""
 2147    prefix: String!
 2148}
 2149
 2150type OpenBugPayload {
 2151    """A unique identifier for the client performing the mutation."""
 2152    clientMutationId: String
 2153    """The affected bug."""
 2154    bug: Bug!
 2155    """The resulting operation."""
 2156    operation: SetStatusOperation!
 2157}
 2158
 2159input CloseBugInput {
 2160    """A unique identifier for the client performing the mutation."""
 2161    clientMutationId: String
 2162    """"The name of the repository. If not set, the default repository is used."""
 2163    repoRef: String
 2164    """The bug ID's prefix."""
 2165    prefix: String!
 2166}
 2167
 2168type CloseBugPayload {
 2169    """A unique identifier for the client performing the mutation."""
 2170    clientMutationId: String
 2171    """The affected bug."""
 2172    bug: Bug!
 2173    """The resulting operation."""
 2174    operation: SetStatusOperation!
 2175}
 2176
 2177input SetTitleInput {
 2178    """A unique identifier for the client performing the mutation."""
 2179    clientMutationId: String
 2180    """"The name of the repository. If not set, the default repository is used."""
 2181    repoRef: String
 2182    """The bug ID's prefix."""
 2183    prefix: String!
 2184    """The new title."""
 2185    title: String!
 2186}
 2187
 2188type SetTitlePayload {
 2189    """A unique identifier for the client performing the mutation."""
 2190    clientMutationId: String
 2191    """The affected bug."""
 2192    bug: Bug!
 2193    """The resulting operation"""
 2194    operation: SetTitleOperation!
 2195}
 2196`, BuiltIn: false},
 2197	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2198interface Operation {
 2199    """The identifier of the operation"""
 2200    id: String!
 2201    """The operations author."""
 2202    author: Identity!
 2203    """The datetime when this operation was issued."""
 2204    date: Time!
 2205}
 2206
 2207# Connection
 2208
 2209"""The connection type for an Operation"""
 2210type OperationConnection {
 2211    edges: [OperationEdge!]!
 2212    nodes: [Operation!]!
 2213    pageInfo: PageInfo!
 2214    totalCount: Int!
 2215}
 2216
 2217"""Represent an Operation"""
 2218type OperationEdge {
 2219    cursor: String!
 2220    node: Operation!
 2221}
 2222
 2223# Operations
 2224
 2225type CreateOperation implements Operation & Authored {
 2226    """The identifier of the operation"""
 2227    id: String!
 2228    """The author of this object."""
 2229    author: Identity!
 2230    """The datetime when this operation was issued."""
 2231    date: Time!
 2232
 2233    title: String!
 2234    message: String!
 2235    files: [Hash!]!
 2236}
 2237
 2238type SetTitleOperation implements Operation & Authored {
 2239    """The identifier of the operation"""
 2240    id: String!
 2241    """The author of this object."""
 2242    author: Identity!
 2243    """The datetime when this operation was issued."""
 2244    date: Time!
 2245
 2246    title: String!
 2247    was: String!
 2248}
 2249
 2250type AddCommentOperation implements Operation & Authored {
 2251    """The identifier of the operation"""
 2252    id: String!
 2253    """The author of this object."""
 2254    author: Identity!
 2255    """The datetime when this operation was issued."""
 2256    date: Time!
 2257
 2258    message: String!
 2259    files: [Hash!]!
 2260}
 2261
 2262type EditCommentOperation implements Operation & Authored {
 2263    """The identifier of the operation"""
 2264    id: String!
 2265    """The author of this object."""
 2266    author: Identity!
 2267    """The datetime when this operation was issued."""
 2268    date: Time!
 2269
 2270    target: String!
 2271    message: String!
 2272    files: [Hash!]!
 2273}
 2274
 2275type SetStatusOperation implements Operation & Authored {
 2276    """The identifier of the operation"""
 2277    id: String!
 2278    """The author of this object."""
 2279    author: Identity!
 2280    """The datetime when this operation was issued."""
 2281    date: Time!
 2282
 2283    status: Status!
 2284}
 2285
 2286type LabelChangeOperation implements Operation & Authored {
 2287    """The identifier of the operation"""
 2288    id: String!
 2289    """The author of this object."""
 2290    author: Identity!
 2291    """The datetime when this operation was issued."""
 2292    date: Time!
 2293
 2294    added: [Label!]!
 2295    removed: [Label!]!
 2296}
 2297`, BuiltIn: false},
 2298	&ast.Source{Name: "schema/repository.graphql", Input: `
 2299type Repository {
 2300    """The name of the repository"""
 2301    name: String
 2302
 2303    """All the bugs"""
 2304    allBugs(
 2305        """Returns the elements in the list that come after the specified cursor."""
 2306        after: String
 2307        """Returns the elements in the list that come before the specified cursor."""
 2308        before: String
 2309        """Returns the first _n_ elements from the list."""
 2310        first: Int
 2311        """Returns the last _n_ elements from the list."""
 2312        last: Int
 2313        """A query to select and order bugs."""
 2314        query: String
 2315    ): BugConnection!
 2316
 2317    bug(prefix: String!): Bug
 2318
 2319    """All the identities"""
 2320    allIdentities(
 2321        """Returns the elements in the list that come after the specified cursor."""
 2322        after: String
 2323        """Returns the elements in the list that come before the specified cursor."""
 2324        before: String
 2325        """Returns the first _n_ elements from the list."""
 2326        first: Int
 2327        """Returns the last _n_ elements from the list."""
 2328        last: Int
 2329    ): IdentityConnection!
 2330
 2331    identity(prefix: String!): Identity
 2332
 2333    """The identity created or selected by the user as its own"""
 2334    userIdentity: Identity
 2335
 2336    """List of valid labels."""
 2337    validLabels(
 2338        """Returns the elements in the list that come after the specified cursor."""
 2339        after: String
 2340        """Returns the elements in the list that come before the specified cursor."""
 2341        before: String
 2342        """Returns the first _n_ elements from the list."""
 2343        first: Int
 2344        """Returns the last _n_ elements from the list."""
 2345        last: Int
 2346    ): LabelConnection!
 2347}`, BuiltIn: false},
 2348	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2349    """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
 2350    repository(ref: String): Repository
 2351}
 2352
 2353type Mutation {
 2354    """Create a new bug"""
 2355    newBug(input: NewBugInput!): NewBugPayload!
 2356    """Add a new comment to a bug"""
 2357    addComment(input: AddCommentInput!): AddCommentPayload!
 2358    """Change a comment of a bug"""
 2359    editComment(input: EditCommentInput!): EditCommentPayload!
 2360    """Add or remove a set of label on a bug"""
 2361    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2362    """Change a bug's status to open"""
 2363    openBug(input: OpenBugInput!): OpenBugPayload!
 2364    """Change a bug's status to closed"""
 2365    closeBug(input: CloseBugInput!): CloseBugPayload!
 2366    """Change a bug's title"""
 2367    setTitle(input: SetTitleInput!): SetTitlePayload!
 2368}
 2369`, BuiltIn: false},
 2370	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2371interface TimelineItem {
 2372    """The identifier of the source operation"""
 2373    id: String!
 2374}
 2375
 2376"""CommentHistoryStep hold one version of a message in the history"""
 2377type CommentHistoryStep {
 2378    message: String!
 2379    date: Time!
 2380}
 2381
 2382# Connection
 2383
 2384"""The connection type for TimelineItem"""
 2385type TimelineItemConnection {
 2386    edges: [TimelineItemEdge!]!
 2387    nodes: [TimelineItem!]!
 2388    pageInfo: PageInfo!
 2389    totalCount: Int!
 2390}
 2391
 2392"""Represent a TimelineItem"""
 2393type TimelineItemEdge {
 2394    cursor: String!
 2395    node: TimelineItem!
 2396}
 2397
 2398# Items
 2399
 2400"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2401type CreateTimelineItem implements TimelineItem & Authored {
 2402    """The identifier of the source operation"""
 2403    id: String!
 2404    author: Identity!
 2405    message: String!
 2406    messageIsEmpty: Boolean!
 2407    files: [Hash!]!
 2408    createdAt: Time!
 2409    lastEdit: Time!
 2410    edited: Boolean!
 2411    history: [CommentHistoryStep!]!
 2412}
 2413
 2414"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2415type AddCommentTimelineItem implements TimelineItem & Authored {
 2416    """The identifier of the source operation"""
 2417    id: String!
 2418    author: Identity!
 2419    message: String!
 2420    messageIsEmpty: Boolean!
 2421    files: [Hash!]!
 2422    createdAt: Time!
 2423    lastEdit: Time!
 2424    edited: Boolean!
 2425    history: [CommentHistoryStep!]!
 2426}
 2427
 2428"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2429type LabelChangeTimelineItem implements TimelineItem & Authored {
 2430    """The identifier of the source operation"""
 2431    id: String!
 2432    author: Identity!
 2433    date: Time!
 2434    added: [Label!]!
 2435    removed: [Label!]!
 2436}
 2437
 2438"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2439type SetStatusTimelineItem implements TimelineItem & Authored {
 2440    """The identifier of the source operation"""
 2441    id: String!
 2442    author: Identity!
 2443    date: Time!
 2444    status: Status!
 2445}
 2446
 2447"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2448type SetTitleTimelineItem implements TimelineItem & Authored {
 2449    """The identifier of the source operation"""
 2450    id: String!
 2451    author: Identity!
 2452    date: Time!
 2453    title: String!
 2454    was: String!
 2455}
 2456`, BuiltIn: false},
 2457	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2458scalar Hash
 2459
 2460"""Defines a color by red, green and blue components."""
 2461type Color {
 2462    """Red component of the color."""
 2463    R: Int!
 2464    """Green component of the color."""
 2465    G: Int!
 2466    """Blue component of the color."""
 2467    B: Int!
 2468}
 2469
 2470"""Information about pagination in a connection."""
 2471type PageInfo {
 2472    """When paginating forwards, are there more items?"""
 2473    hasNextPage: Boolean!
 2474    """When paginating backwards, are there more items?"""
 2475    hasPreviousPage: Boolean!
 2476    """When paginating backwards, the cursor to continue."""
 2477    startCursor: String!
 2478    """When paginating forwards, the cursor to continue."""
 2479    endCursor: String!
 2480}
 2481
 2482"""An object that has an author."""
 2483interface Authored {
 2484    """The author of this object."""
 2485    author: Identity!
 2486}
 2487`, BuiltIn: false},
 2488}
 2489var parsedSchema = gqlparser.MustLoadSchema(sources...)
 2490
 2491// endregion ************************** generated!.gotpl **************************
 2492
 2493// region    ***************************** args.gotpl *****************************
 2494
 2495func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2496	var err error
 2497	args := map[string]interface{}{}
 2498	var arg0 *string
 2499	if tmp, ok := rawArgs["after"]; ok {
 2500		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2501		if err != nil {
 2502			return nil, err
 2503		}
 2504	}
 2505	args["after"] = arg0
 2506	var arg1 *string
 2507	if tmp, ok := rawArgs["before"]; ok {
 2508		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2509		if err != nil {
 2510			return nil, err
 2511		}
 2512	}
 2513	args["before"] = arg1
 2514	var arg2 *int
 2515	if tmp, ok := rawArgs["first"]; ok {
 2516		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2517		if err != nil {
 2518			return nil, err
 2519		}
 2520	}
 2521	args["first"] = arg2
 2522	var arg3 *int
 2523	if tmp, ok := rawArgs["last"]; ok {
 2524		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2525		if err != nil {
 2526			return nil, err
 2527		}
 2528	}
 2529	args["last"] = arg3
 2530	return args, nil
 2531}
 2532
 2533func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2534	var err error
 2535	args := map[string]interface{}{}
 2536	var arg0 *string
 2537	if tmp, ok := rawArgs["after"]; ok {
 2538		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2539		if err != nil {
 2540			return nil, err
 2541		}
 2542	}
 2543	args["after"] = arg0
 2544	var arg1 *string
 2545	if tmp, ok := rawArgs["before"]; ok {
 2546		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2547		if err != nil {
 2548			return nil, err
 2549		}
 2550	}
 2551	args["before"] = arg1
 2552	var arg2 *int
 2553	if tmp, ok := rawArgs["first"]; ok {
 2554		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2555		if err != nil {
 2556			return nil, err
 2557		}
 2558	}
 2559	args["first"] = arg2
 2560	var arg3 *int
 2561	if tmp, ok := rawArgs["last"]; ok {
 2562		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2563		if err != nil {
 2564			return nil, err
 2565		}
 2566	}
 2567	args["last"] = arg3
 2568	return args, nil
 2569}
 2570
 2571func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2572	var err error
 2573	args := map[string]interface{}{}
 2574	var arg0 *string
 2575	if tmp, ok := rawArgs["after"]; ok {
 2576		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2577		if err != nil {
 2578			return nil, err
 2579		}
 2580	}
 2581	args["after"] = arg0
 2582	var arg1 *string
 2583	if tmp, ok := rawArgs["before"]; ok {
 2584		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2585		if err != nil {
 2586			return nil, err
 2587		}
 2588	}
 2589	args["before"] = arg1
 2590	var arg2 *int
 2591	if tmp, ok := rawArgs["first"]; ok {
 2592		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2593		if err != nil {
 2594			return nil, err
 2595		}
 2596	}
 2597	args["first"] = arg2
 2598	var arg3 *int
 2599	if tmp, ok := rawArgs["last"]; ok {
 2600		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2601		if err != nil {
 2602			return nil, err
 2603		}
 2604	}
 2605	args["last"] = arg3
 2606	return args, nil
 2607}
 2608
 2609func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2610	var err error
 2611	args := map[string]interface{}{}
 2612	var arg0 *string
 2613	if tmp, ok := rawArgs["after"]; ok {
 2614		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2615		if err != nil {
 2616			return nil, err
 2617		}
 2618	}
 2619	args["after"] = arg0
 2620	var arg1 *string
 2621	if tmp, ok := rawArgs["before"]; ok {
 2622		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2623		if err != nil {
 2624			return nil, err
 2625		}
 2626	}
 2627	args["before"] = arg1
 2628	var arg2 *int
 2629	if tmp, ok := rawArgs["first"]; ok {
 2630		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2631		if err != nil {
 2632			return nil, err
 2633		}
 2634	}
 2635	args["first"] = arg2
 2636	var arg3 *int
 2637	if tmp, ok := rawArgs["last"]; ok {
 2638		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2639		if err != nil {
 2640			return nil, err
 2641		}
 2642	}
 2643	args["last"] = arg3
 2644	return args, nil
 2645}
 2646
 2647func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2648	var err error
 2649	args := map[string]interface{}{}
 2650	var arg0 *string
 2651	if tmp, ok := rawArgs["after"]; ok {
 2652		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2653		if err != nil {
 2654			return nil, err
 2655		}
 2656	}
 2657	args["after"] = arg0
 2658	var arg1 *string
 2659	if tmp, ok := rawArgs["before"]; ok {
 2660		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2661		if err != nil {
 2662			return nil, err
 2663		}
 2664	}
 2665	args["before"] = arg1
 2666	var arg2 *int
 2667	if tmp, ok := rawArgs["first"]; ok {
 2668		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2669		if err != nil {
 2670			return nil, err
 2671		}
 2672	}
 2673	args["first"] = arg2
 2674	var arg3 *int
 2675	if tmp, ok := rawArgs["last"]; ok {
 2676		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2677		if err != nil {
 2678			return nil, err
 2679		}
 2680	}
 2681	args["last"] = arg3
 2682	return args, nil
 2683}
 2684
 2685func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2686	var err error
 2687	args := map[string]interface{}{}
 2688	var arg0 models.AddCommentInput
 2689	if tmp, ok := rawArgs["input"]; ok {
 2690		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2691		if err != nil {
 2692			return nil, err
 2693		}
 2694	}
 2695	args["input"] = arg0
 2696	return args, nil
 2697}
 2698
 2699func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2700	var err error
 2701	args := map[string]interface{}{}
 2702	var arg0 *models.ChangeLabelInput
 2703	if tmp, ok := rawArgs["input"]; ok {
 2704		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2705		if err != nil {
 2706			return nil, err
 2707		}
 2708	}
 2709	args["input"] = arg0
 2710	return args, nil
 2711}
 2712
 2713func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2714	var err error
 2715	args := map[string]interface{}{}
 2716	var arg0 models.CloseBugInput
 2717	if tmp, ok := rawArgs["input"]; ok {
 2718		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2719		if err != nil {
 2720			return nil, err
 2721		}
 2722	}
 2723	args["input"] = arg0
 2724	return args, nil
 2725}
 2726
 2727func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2728	var err error
 2729	args := map[string]interface{}{}
 2730	var arg0 models.EditCommentInput
 2731	if tmp, ok := rawArgs["input"]; ok {
 2732		arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
 2733		if err != nil {
 2734			return nil, err
 2735		}
 2736	}
 2737	args["input"] = arg0
 2738	return args, nil
 2739}
 2740
 2741func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2742	var err error
 2743	args := map[string]interface{}{}
 2744	var arg0 models.NewBugInput
 2745	if tmp, ok := rawArgs["input"]; ok {
 2746		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2747		if err != nil {
 2748			return nil, err
 2749		}
 2750	}
 2751	args["input"] = arg0
 2752	return args, nil
 2753}
 2754
 2755func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2756	var err error
 2757	args := map[string]interface{}{}
 2758	var arg0 models.OpenBugInput
 2759	if tmp, ok := rawArgs["input"]; ok {
 2760		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2761		if err != nil {
 2762			return nil, err
 2763		}
 2764	}
 2765	args["input"] = arg0
 2766	return args, nil
 2767}
 2768
 2769func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2770	var err error
 2771	args := map[string]interface{}{}
 2772	var arg0 models.SetTitleInput
 2773	if tmp, ok := rawArgs["input"]; ok {
 2774		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2775		if err != nil {
 2776			return nil, err
 2777		}
 2778	}
 2779	args["input"] = arg0
 2780	return args, nil
 2781}
 2782
 2783func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2784	var err error
 2785	args := map[string]interface{}{}
 2786	var arg0 string
 2787	if tmp, ok := rawArgs["name"]; ok {
 2788		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2789		if err != nil {
 2790			return nil, err
 2791		}
 2792	}
 2793	args["name"] = arg0
 2794	return args, nil
 2795}
 2796
 2797func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2798	var err error
 2799	args := map[string]interface{}{}
 2800	var arg0 *string
 2801	if tmp, ok := rawArgs["ref"]; ok {
 2802		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2803		if err != nil {
 2804			return nil, err
 2805		}
 2806	}
 2807	args["ref"] = arg0
 2808	return args, nil
 2809}
 2810
 2811func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2812	var err error
 2813	args := map[string]interface{}{}
 2814	var arg0 *string
 2815	if tmp, ok := rawArgs["after"]; ok {
 2816		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2817		if err != nil {
 2818			return nil, err
 2819		}
 2820	}
 2821	args["after"] = arg0
 2822	var arg1 *string
 2823	if tmp, ok := rawArgs["before"]; ok {
 2824		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2825		if err != nil {
 2826			return nil, err
 2827		}
 2828	}
 2829	args["before"] = arg1
 2830	var arg2 *int
 2831	if tmp, ok := rawArgs["first"]; ok {
 2832		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2833		if err != nil {
 2834			return nil, err
 2835		}
 2836	}
 2837	args["first"] = arg2
 2838	var arg3 *int
 2839	if tmp, ok := rawArgs["last"]; ok {
 2840		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2841		if err != nil {
 2842			return nil, err
 2843		}
 2844	}
 2845	args["last"] = arg3
 2846	var arg4 *string
 2847	if tmp, ok := rawArgs["query"]; ok {
 2848		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2849		if err != nil {
 2850			return nil, err
 2851		}
 2852	}
 2853	args["query"] = arg4
 2854	return args, nil
 2855}
 2856
 2857func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2858	var err error
 2859	args := map[string]interface{}{}
 2860	var arg0 *string
 2861	if tmp, ok := rawArgs["after"]; ok {
 2862		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2863		if err != nil {
 2864			return nil, err
 2865		}
 2866	}
 2867	args["after"] = arg0
 2868	var arg1 *string
 2869	if tmp, ok := rawArgs["before"]; ok {
 2870		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2871		if err != nil {
 2872			return nil, err
 2873		}
 2874	}
 2875	args["before"] = arg1
 2876	var arg2 *int
 2877	if tmp, ok := rawArgs["first"]; ok {
 2878		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2879		if err != nil {
 2880			return nil, err
 2881		}
 2882	}
 2883	args["first"] = arg2
 2884	var arg3 *int
 2885	if tmp, ok := rawArgs["last"]; ok {
 2886		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2887		if err != nil {
 2888			return nil, err
 2889		}
 2890	}
 2891	args["last"] = arg3
 2892	return args, nil
 2893}
 2894
 2895func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2896	var err error
 2897	args := map[string]interface{}{}
 2898	var arg0 string
 2899	if tmp, ok := rawArgs["prefix"]; ok {
 2900		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2901		if err != nil {
 2902			return nil, err
 2903		}
 2904	}
 2905	args["prefix"] = arg0
 2906	return args, nil
 2907}
 2908
 2909func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2910	var err error
 2911	args := map[string]interface{}{}
 2912	var arg0 string
 2913	if tmp, ok := rawArgs["prefix"]; ok {
 2914		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2915		if err != nil {
 2916			return nil, err
 2917		}
 2918	}
 2919	args["prefix"] = arg0
 2920	return args, nil
 2921}
 2922
 2923func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2924	var err error
 2925	args := map[string]interface{}{}
 2926	var arg0 *string
 2927	if tmp, ok := rawArgs["after"]; ok {
 2928		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2929		if err != nil {
 2930			return nil, err
 2931		}
 2932	}
 2933	args["after"] = arg0
 2934	var arg1 *string
 2935	if tmp, ok := rawArgs["before"]; ok {
 2936		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2937		if err != nil {
 2938			return nil, err
 2939		}
 2940	}
 2941	args["before"] = arg1
 2942	var arg2 *int
 2943	if tmp, ok := rawArgs["first"]; ok {
 2944		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2945		if err != nil {
 2946			return nil, err
 2947		}
 2948	}
 2949	args["first"] = arg2
 2950	var arg3 *int
 2951	if tmp, ok := rawArgs["last"]; ok {
 2952		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2953		if err != nil {
 2954			return nil, err
 2955		}
 2956	}
 2957	args["last"] = arg3
 2958	return args, nil
 2959}
 2960
 2961func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2962	var err error
 2963	args := map[string]interface{}{}
 2964	var arg0 bool
 2965	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2966		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2967		if err != nil {
 2968			return nil, err
 2969		}
 2970	}
 2971	args["includeDeprecated"] = arg0
 2972	return args, nil
 2973}
 2974
 2975func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2976	var err error
 2977	args := map[string]interface{}{}
 2978	var arg0 bool
 2979	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2980		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2981		if err != nil {
 2982			return nil, err
 2983		}
 2984	}
 2985	args["includeDeprecated"] = arg0
 2986	return args, nil
 2987}
 2988
 2989// endregion ***************************** args.gotpl *****************************
 2990
 2991// region    ************************** directives.gotpl **************************
 2992
 2993// endregion ************************** directives.gotpl **************************
 2994
 2995// region    **************************** field.gotpl *****************************
 2996
 2997func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2998	defer func() {
 2999		if r := recover(); r != nil {
 3000			ec.Error(ctx, ec.Recover(ctx, r))
 3001			ret = graphql.Null
 3002		}
 3003	}()
 3004	fc := &graphql.FieldContext{
 3005		Object:   "AddCommentOperation",
 3006		Field:    field,
 3007		Args:     nil,
 3008		IsMethod: true,
 3009	}
 3010
 3011	ctx = graphql.WithFieldContext(ctx, fc)
 3012	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3013		ctx = rctx // use context from middleware stack in children
 3014		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 3015	})
 3016	if err != nil {
 3017		ec.Error(ctx, err)
 3018		return graphql.Null
 3019	}
 3020	if resTmp == nil {
 3021		if !graphql.HasFieldError(ctx, fc) {
 3022			ec.Errorf(ctx, "must not be null")
 3023		}
 3024		return graphql.Null
 3025	}
 3026	res := resTmp.(string)
 3027	fc.Result = res
 3028	return ec.marshalNString2string(ctx, field.Selections, res)
 3029}
 3030
 3031func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3032	defer func() {
 3033		if r := recover(); r != nil {
 3034			ec.Error(ctx, ec.Recover(ctx, r))
 3035			ret = graphql.Null
 3036		}
 3037	}()
 3038	fc := &graphql.FieldContext{
 3039		Object:   "AddCommentOperation",
 3040		Field:    field,
 3041		Args:     nil,
 3042		IsMethod: true,
 3043	}
 3044
 3045	ctx = graphql.WithFieldContext(ctx, fc)
 3046	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3047		ctx = rctx // use context from middleware stack in children
 3048		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
 3049	})
 3050	if err != nil {
 3051		ec.Error(ctx, err)
 3052		return graphql.Null
 3053	}
 3054	if resTmp == nil {
 3055		if !graphql.HasFieldError(ctx, fc) {
 3056			ec.Errorf(ctx, "must not be null")
 3057		}
 3058		return graphql.Null
 3059	}
 3060	res := resTmp.(models.IdentityWrapper)
 3061	fc.Result = res
 3062	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3063}
 3064
 3065func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3066	defer func() {
 3067		if r := recover(); r != nil {
 3068			ec.Error(ctx, ec.Recover(ctx, r))
 3069			ret = graphql.Null
 3070		}
 3071	}()
 3072	fc := &graphql.FieldContext{
 3073		Object:   "AddCommentOperation",
 3074		Field:    field,
 3075		Args:     nil,
 3076		IsMethod: true,
 3077	}
 3078
 3079	ctx = graphql.WithFieldContext(ctx, fc)
 3080	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3081		ctx = rctx // use context from middleware stack in children
 3082		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 3083	})
 3084	if err != nil {
 3085		ec.Error(ctx, err)
 3086		return graphql.Null
 3087	}
 3088	if resTmp == nil {
 3089		if !graphql.HasFieldError(ctx, fc) {
 3090			ec.Errorf(ctx, "must not be null")
 3091		}
 3092		return graphql.Null
 3093	}
 3094	res := resTmp.(*time.Time)
 3095	fc.Result = res
 3096	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3097}
 3098
 3099func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3100	defer func() {
 3101		if r := recover(); r != nil {
 3102			ec.Error(ctx, ec.Recover(ctx, r))
 3103			ret = graphql.Null
 3104		}
 3105	}()
 3106	fc := &graphql.FieldContext{
 3107		Object:   "AddCommentOperation",
 3108		Field:    field,
 3109		Args:     nil,
 3110		IsMethod: false,
 3111	}
 3112
 3113	ctx = graphql.WithFieldContext(ctx, fc)
 3114	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3115		ctx = rctx // use context from middleware stack in children
 3116		return obj.Message, nil
 3117	})
 3118	if err != nil {
 3119		ec.Error(ctx, err)
 3120		return graphql.Null
 3121	}
 3122	if resTmp == nil {
 3123		if !graphql.HasFieldError(ctx, fc) {
 3124			ec.Errorf(ctx, "must not be null")
 3125		}
 3126		return graphql.Null
 3127	}
 3128	res := resTmp.(string)
 3129	fc.Result = res
 3130	return ec.marshalNString2string(ctx, field.Selections, res)
 3131}
 3132
 3133func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3134	defer func() {
 3135		if r := recover(); r != nil {
 3136			ec.Error(ctx, ec.Recover(ctx, r))
 3137			ret = graphql.Null
 3138		}
 3139	}()
 3140	fc := &graphql.FieldContext{
 3141		Object:   "AddCommentOperation",
 3142		Field:    field,
 3143		Args:     nil,
 3144		IsMethod: false,
 3145	}
 3146
 3147	ctx = graphql.WithFieldContext(ctx, fc)
 3148	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3149		ctx = rctx // use context from middleware stack in children
 3150		return obj.Files, nil
 3151	})
 3152	if err != nil {
 3153		ec.Error(ctx, err)
 3154		return graphql.Null
 3155	}
 3156	if resTmp == nil {
 3157		if !graphql.HasFieldError(ctx, fc) {
 3158			ec.Errorf(ctx, "must not be null")
 3159		}
 3160		return graphql.Null
 3161	}
 3162	res := resTmp.([]repository.Hash)
 3163	fc.Result = res
 3164	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 3165}
 3166
 3167func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3168	defer func() {
 3169		if r := recover(); r != nil {
 3170			ec.Error(ctx, ec.Recover(ctx, r))
 3171			ret = graphql.Null
 3172		}
 3173	}()
 3174	fc := &graphql.FieldContext{
 3175		Object:   "AddCommentPayload",
 3176		Field:    field,
 3177		Args:     nil,
 3178		IsMethod: false,
 3179	}
 3180
 3181	ctx = graphql.WithFieldContext(ctx, fc)
 3182	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3183		ctx = rctx // use context from middleware stack in children
 3184		return obj.ClientMutationID, nil
 3185	})
 3186	if err != nil {
 3187		ec.Error(ctx, err)
 3188		return graphql.Null
 3189	}
 3190	if resTmp == nil {
 3191		return graphql.Null
 3192	}
 3193	res := resTmp.(*string)
 3194	fc.Result = res
 3195	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3196}
 3197
 3198func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3199	defer func() {
 3200		if r := recover(); r != nil {
 3201			ec.Error(ctx, ec.Recover(ctx, r))
 3202			ret = graphql.Null
 3203		}
 3204	}()
 3205	fc := &graphql.FieldContext{
 3206		Object:   "AddCommentPayload",
 3207		Field:    field,
 3208		Args:     nil,
 3209		IsMethod: false,
 3210	}
 3211
 3212	ctx = graphql.WithFieldContext(ctx, fc)
 3213	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3214		ctx = rctx // use context from middleware stack in children
 3215		return obj.Bug, nil
 3216	})
 3217	if err != nil {
 3218		ec.Error(ctx, err)
 3219		return graphql.Null
 3220	}
 3221	if resTmp == nil {
 3222		if !graphql.HasFieldError(ctx, fc) {
 3223			ec.Errorf(ctx, "must not be null")
 3224		}
 3225		return graphql.Null
 3226	}
 3227	res := resTmp.(models.BugWrapper)
 3228	fc.Result = res
 3229	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 3230}
 3231
 3232func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3233	defer func() {
 3234		if r := recover(); r != nil {
 3235			ec.Error(ctx, ec.Recover(ctx, r))
 3236			ret = graphql.Null
 3237		}
 3238	}()
 3239	fc := &graphql.FieldContext{
 3240		Object:   "AddCommentPayload",
 3241		Field:    field,
 3242		Args:     nil,
 3243		IsMethod: false,
 3244	}
 3245
 3246	ctx = graphql.WithFieldContext(ctx, fc)
 3247	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3248		ctx = rctx // use context from middleware stack in children
 3249		return obj.Operation, nil
 3250	})
 3251	if err != nil {
 3252		ec.Error(ctx, err)
 3253		return graphql.Null
 3254	}
 3255	if resTmp == nil {
 3256		if !graphql.HasFieldError(ctx, fc) {
 3257			ec.Errorf(ctx, "must not be null")
 3258		}
 3259		return graphql.Null
 3260	}
 3261	res := resTmp.(*bug.AddCommentOperation)
 3262	fc.Result = res
 3263	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3264}
 3265
 3266func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3267	defer func() {
 3268		if r := recover(); r != nil {
 3269			ec.Error(ctx, ec.Recover(ctx, r))
 3270			ret = graphql.Null
 3271		}
 3272	}()
 3273	fc := &graphql.FieldContext{
 3274		Object:   "AddCommentTimelineItem",
 3275		Field:    field,
 3276		Args:     nil,
 3277		IsMethod: true,
 3278	}
 3279
 3280	ctx = graphql.WithFieldContext(ctx, fc)
 3281	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3282		ctx = rctx // use context from middleware stack in children
 3283		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3284	})
 3285	if err != nil {
 3286		ec.Error(ctx, err)
 3287		return graphql.Null
 3288	}
 3289	if resTmp == nil {
 3290		if !graphql.HasFieldError(ctx, fc) {
 3291			ec.Errorf(ctx, "must not be null")
 3292		}
 3293		return graphql.Null
 3294	}
 3295	res := resTmp.(string)
 3296	fc.Result = res
 3297	return ec.marshalNString2string(ctx, field.Selections, res)
 3298}
 3299
 3300func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3301	defer func() {
 3302		if r := recover(); r != nil {
 3303			ec.Error(ctx, ec.Recover(ctx, r))
 3304			ret = graphql.Null
 3305		}
 3306	}()
 3307	fc := &graphql.FieldContext{
 3308		Object:   "AddCommentTimelineItem",
 3309		Field:    field,
 3310		Args:     nil,
 3311		IsMethod: true,
 3312	}
 3313
 3314	ctx = graphql.WithFieldContext(ctx, fc)
 3315	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3316		ctx = rctx // use context from middleware stack in children
 3317		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
 3318	})
 3319	if err != nil {
 3320		ec.Error(ctx, err)
 3321		return graphql.Null
 3322	}
 3323	if resTmp == nil {
 3324		if !graphql.HasFieldError(ctx, fc) {
 3325			ec.Errorf(ctx, "must not be null")
 3326		}
 3327		return graphql.Null
 3328	}
 3329	res := resTmp.(models.IdentityWrapper)
 3330	fc.Result = res
 3331	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3332}
 3333
 3334func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3335	defer func() {
 3336		if r := recover(); r != nil {
 3337			ec.Error(ctx, ec.Recover(ctx, r))
 3338			ret = graphql.Null
 3339		}
 3340	}()
 3341	fc := &graphql.FieldContext{
 3342		Object:   "AddCommentTimelineItem",
 3343		Field:    field,
 3344		Args:     nil,
 3345		IsMethod: false,
 3346	}
 3347
 3348	ctx = graphql.WithFieldContext(ctx, fc)
 3349	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3350		ctx = rctx // use context from middleware stack in children
 3351		return obj.Message, nil
 3352	})
 3353	if err != nil {
 3354		ec.Error(ctx, err)
 3355		return graphql.Null
 3356	}
 3357	if resTmp == nil {
 3358		if !graphql.HasFieldError(ctx, fc) {
 3359			ec.Errorf(ctx, "must not be null")
 3360		}
 3361		return graphql.Null
 3362	}
 3363	res := resTmp.(string)
 3364	fc.Result = res
 3365	return ec.marshalNString2string(ctx, field.Selections, res)
 3366}
 3367
 3368func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3369	defer func() {
 3370		if r := recover(); r != nil {
 3371			ec.Error(ctx, ec.Recover(ctx, r))
 3372			ret = graphql.Null
 3373		}
 3374	}()
 3375	fc := &graphql.FieldContext{
 3376		Object:   "AddCommentTimelineItem",
 3377		Field:    field,
 3378		Args:     nil,
 3379		IsMethod: true,
 3380	}
 3381
 3382	ctx = graphql.WithFieldContext(ctx, fc)
 3383	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3384		ctx = rctx // use context from middleware stack in children
 3385		return obj.MessageIsEmpty(), nil
 3386	})
 3387	if err != nil {
 3388		ec.Error(ctx, err)
 3389		return graphql.Null
 3390	}
 3391	if resTmp == nil {
 3392		if !graphql.HasFieldError(ctx, fc) {
 3393			ec.Errorf(ctx, "must not be null")
 3394		}
 3395		return graphql.Null
 3396	}
 3397	res := resTmp.(bool)
 3398	fc.Result = res
 3399	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3400}
 3401
 3402func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3403	defer func() {
 3404		if r := recover(); r != nil {
 3405			ec.Error(ctx, ec.Recover(ctx, r))
 3406			ret = graphql.Null
 3407		}
 3408	}()
 3409	fc := &graphql.FieldContext{
 3410		Object:   "AddCommentTimelineItem",
 3411		Field:    field,
 3412		Args:     nil,
 3413		IsMethod: false,
 3414	}
 3415
 3416	ctx = graphql.WithFieldContext(ctx, fc)
 3417	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3418		ctx = rctx // use context from middleware stack in children
 3419		return obj.Files, nil
 3420	})
 3421	if err != nil {
 3422		ec.Error(ctx, err)
 3423		return graphql.Null
 3424	}
 3425	if resTmp == nil {
 3426		if !graphql.HasFieldError(ctx, fc) {
 3427			ec.Errorf(ctx, "must not be null")
 3428		}
 3429		return graphql.Null
 3430	}
 3431	res := resTmp.([]repository.Hash)
 3432	fc.Result = res
 3433	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 3434}
 3435
 3436func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3437	defer func() {
 3438		if r := recover(); r != nil {
 3439			ec.Error(ctx, ec.Recover(ctx, r))
 3440			ret = graphql.Null
 3441		}
 3442	}()
 3443	fc := &graphql.FieldContext{
 3444		Object:   "AddCommentTimelineItem",
 3445		Field:    field,
 3446		Args:     nil,
 3447		IsMethod: true,
 3448	}
 3449
 3450	ctx = graphql.WithFieldContext(ctx, fc)
 3451	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3452		ctx = rctx // use context from middleware stack in children
 3453		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3454	})
 3455	if err != nil {
 3456		ec.Error(ctx, err)
 3457		return graphql.Null
 3458	}
 3459	if resTmp == nil {
 3460		if !graphql.HasFieldError(ctx, fc) {
 3461			ec.Errorf(ctx, "must not be null")
 3462		}
 3463		return graphql.Null
 3464	}
 3465	res := resTmp.(*time.Time)
 3466	fc.Result = res
 3467	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3468}
 3469
 3470func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3471	defer func() {
 3472		if r := recover(); r != nil {
 3473			ec.Error(ctx, ec.Recover(ctx, r))
 3474			ret = graphql.Null
 3475		}
 3476	}()
 3477	fc := &graphql.FieldContext{
 3478		Object:   "AddCommentTimelineItem",
 3479		Field:    field,
 3480		Args:     nil,
 3481		IsMethod: true,
 3482	}
 3483
 3484	ctx = graphql.WithFieldContext(ctx, fc)
 3485	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3486		ctx = rctx // use context from middleware stack in children
 3487		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3488	})
 3489	if err != nil {
 3490		ec.Error(ctx, err)
 3491		return graphql.Null
 3492	}
 3493	if resTmp == nil {
 3494		if !graphql.HasFieldError(ctx, fc) {
 3495			ec.Errorf(ctx, "must not be null")
 3496		}
 3497		return graphql.Null
 3498	}
 3499	res := resTmp.(*time.Time)
 3500	fc.Result = res
 3501	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3502}
 3503
 3504func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3505	defer func() {
 3506		if r := recover(); r != nil {
 3507			ec.Error(ctx, ec.Recover(ctx, r))
 3508			ret = graphql.Null
 3509		}
 3510	}()
 3511	fc := &graphql.FieldContext{
 3512		Object:   "AddCommentTimelineItem",
 3513		Field:    field,
 3514		Args:     nil,
 3515		IsMethod: true,
 3516	}
 3517
 3518	ctx = graphql.WithFieldContext(ctx, fc)
 3519	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3520		ctx = rctx // use context from middleware stack in children
 3521		return obj.Edited(), nil
 3522	})
 3523	if err != nil {
 3524		ec.Error(ctx, err)
 3525		return graphql.Null
 3526	}
 3527	if resTmp == nil {
 3528		if !graphql.HasFieldError(ctx, fc) {
 3529			ec.Errorf(ctx, "must not be null")
 3530		}
 3531		return graphql.Null
 3532	}
 3533	res := resTmp.(bool)
 3534	fc.Result = res
 3535	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3536}
 3537
 3538func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3539	defer func() {
 3540		if r := recover(); r != nil {
 3541			ec.Error(ctx, ec.Recover(ctx, r))
 3542			ret = graphql.Null
 3543		}
 3544	}()
 3545	fc := &graphql.FieldContext{
 3546		Object:   "AddCommentTimelineItem",
 3547		Field:    field,
 3548		Args:     nil,
 3549		IsMethod: false,
 3550	}
 3551
 3552	ctx = graphql.WithFieldContext(ctx, fc)
 3553	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3554		ctx = rctx // use context from middleware stack in children
 3555		return obj.History, nil
 3556	})
 3557	if err != nil {
 3558		ec.Error(ctx, err)
 3559		return graphql.Null
 3560	}
 3561	if resTmp == nil {
 3562		if !graphql.HasFieldError(ctx, fc) {
 3563			ec.Errorf(ctx, "must not be null")
 3564		}
 3565		return graphql.Null
 3566	}
 3567	res := resTmp.([]bug.CommentHistoryStep)
 3568	fc.Result = res
 3569	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3570}
 3571
 3572func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3573	defer func() {
 3574		if r := recover(); r != nil {
 3575			ec.Error(ctx, ec.Recover(ctx, r))
 3576			ret = graphql.Null
 3577		}
 3578	}()
 3579	fc := &graphql.FieldContext{
 3580		Object:   "Bug",
 3581		Field:    field,
 3582		Args:     nil,
 3583		IsMethod: true,
 3584	}
 3585
 3586	ctx = graphql.WithFieldContext(ctx, fc)
 3587	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3588		ctx = rctx // use context from middleware stack in children
 3589		return ec.resolvers.Bug().ID(rctx, obj)
 3590	})
 3591	if err != nil {
 3592		ec.Error(ctx, err)
 3593		return graphql.Null
 3594	}
 3595	if resTmp == nil {
 3596		if !graphql.HasFieldError(ctx, fc) {
 3597			ec.Errorf(ctx, "must not be null")
 3598		}
 3599		return graphql.Null
 3600	}
 3601	res := resTmp.(string)
 3602	fc.Result = res
 3603	return ec.marshalNString2string(ctx, field.Selections, res)
 3604}
 3605
 3606func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3607	defer func() {
 3608		if r := recover(); r != nil {
 3609			ec.Error(ctx, ec.Recover(ctx, r))
 3610			ret = graphql.Null
 3611		}
 3612	}()
 3613	fc := &graphql.FieldContext{
 3614		Object:   "Bug",
 3615		Field:    field,
 3616		Args:     nil,
 3617		IsMethod: true,
 3618	}
 3619
 3620	ctx = graphql.WithFieldContext(ctx, fc)
 3621	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3622		ctx = rctx // use context from middleware stack in children
 3623		return ec.resolvers.Bug().HumanID(rctx, obj)
 3624	})
 3625	if err != nil {
 3626		ec.Error(ctx, err)
 3627		return graphql.Null
 3628	}
 3629	if resTmp == nil {
 3630		if !graphql.HasFieldError(ctx, fc) {
 3631			ec.Errorf(ctx, "must not be null")
 3632		}
 3633		return graphql.Null
 3634	}
 3635	res := resTmp.(string)
 3636	fc.Result = res
 3637	return ec.marshalNString2string(ctx, field.Selections, res)
 3638}
 3639
 3640func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3641	defer func() {
 3642		if r := recover(); r != nil {
 3643			ec.Error(ctx, ec.Recover(ctx, r))
 3644			ret = graphql.Null
 3645		}
 3646	}()
 3647	fc := &graphql.FieldContext{
 3648		Object:   "Bug",
 3649		Field:    field,
 3650		Args:     nil,
 3651		IsMethod: true,
 3652	}
 3653
 3654	ctx = graphql.WithFieldContext(ctx, fc)
 3655	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3656		ctx = rctx // use context from middleware stack in children
 3657		return ec.resolvers.Bug().Status(rctx, obj)
 3658	})
 3659	if err != nil {
 3660		ec.Error(ctx, err)
 3661		return graphql.Null
 3662	}
 3663	if resTmp == nil {
 3664		if !graphql.HasFieldError(ctx, fc) {
 3665			ec.Errorf(ctx, "must not be null")
 3666		}
 3667		return graphql.Null
 3668	}
 3669	res := resTmp.(models.Status)
 3670	fc.Result = res
 3671	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3672}
 3673
 3674func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3675	defer func() {
 3676		if r := recover(); r != nil {
 3677			ec.Error(ctx, ec.Recover(ctx, r))
 3678			ret = graphql.Null
 3679		}
 3680	}()
 3681	fc := &graphql.FieldContext{
 3682		Object:   "Bug",
 3683		Field:    field,
 3684		Args:     nil,
 3685		IsMethod: true,
 3686	}
 3687
 3688	ctx = graphql.WithFieldContext(ctx, fc)
 3689	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3690		ctx = rctx // use context from middleware stack in children
 3691		return obj.Title(), nil
 3692	})
 3693	if err != nil {
 3694		ec.Error(ctx, err)
 3695		return graphql.Null
 3696	}
 3697	if resTmp == nil {
 3698		if !graphql.HasFieldError(ctx, fc) {
 3699			ec.Errorf(ctx, "must not be null")
 3700		}
 3701		return graphql.Null
 3702	}
 3703	res := resTmp.(string)
 3704	fc.Result = res
 3705	return ec.marshalNString2string(ctx, field.Selections, res)
 3706}
 3707
 3708func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3709	defer func() {
 3710		if r := recover(); r != nil {
 3711			ec.Error(ctx, ec.Recover(ctx, r))
 3712			ret = graphql.Null
 3713		}
 3714	}()
 3715	fc := &graphql.FieldContext{
 3716		Object:   "Bug",
 3717		Field:    field,
 3718		Args:     nil,
 3719		IsMethod: true,
 3720	}
 3721
 3722	ctx = graphql.WithFieldContext(ctx, fc)
 3723	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3724		ctx = rctx // use context from middleware stack in children
 3725		return obj.Labels(), nil
 3726	})
 3727	if err != nil {
 3728		ec.Error(ctx, err)
 3729		return graphql.Null
 3730	}
 3731	if resTmp == nil {
 3732		if !graphql.HasFieldError(ctx, fc) {
 3733			ec.Errorf(ctx, "must not be null")
 3734		}
 3735		return graphql.Null
 3736	}
 3737	res := resTmp.([]bug.Label)
 3738	fc.Result = res
 3739	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 3740}
 3741
 3742func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3743	defer func() {
 3744		if r := recover(); r != nil {
 3745			ec.Error(ctx, ec.Recover(ctx, r))
 3746			ret = graphql.Null
 3747		}
 3748	}()
 3749	fc := &graphql.FieldContext{
 3750		Object:   "Bug",
 3751		Field:    field,
 3752		Args:     nil,
 3753		IsMethod: true,
 3754	}
 3755
 3756	ctx = graphql.WithFieldContext(ctx, fc)
 3757	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3758		ctx = rctx // use context from middleware stack in children
 3759		return obj.Author()
 3760	})
 3761	if err != nil {
 3762		ec.Error(ctx, err)
 3763		return graphql.Null
 3764	}
 3765	if resTmp == nil {
 3766		if !graphql.HasFieldError(ctx, fc) {
 3767			ec.Errorf(ctx, "must not be null")
 3768		}
 3769		return graphql.Null
 3770	}
 3771	res := resTmp.(models.IdentityWrapper)
 3772	fc.Result = res
 3773	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3774}
 3775
 3776func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3777	defer func() {
 3778		if r := recover(); r != nil {
 3779			ec.Error(ctx, ec.Recover(ctx, r))
 3780			ret = graphql.Null
 3781		}
 3782	}()
 3783	fc := &graphql.FieldContext{
 3784		Object:   "Bug",
 3785		Field:    field,
 3786		Args:     nil,
 3787		IsMethod: true,
 3788	}
 3789
 3790	ctx = graphql.WithFieldContext(ctx, fc)
 3791	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3792		ctx = rctx // use context from middleware stack in children
 3793		return obj.CreatedAt(), nil
 3794	})
 3795	if err != nil {
 3796		ec.Error(ctx, err)
 3797		return graphql.Null
 3798	}
 3799	if resTmp == nil {
 3800		if !graphql.HasFieldError(ctx, fc) {
 3801			ec.Errorf(ctx, "must not be null")
 3802		}
 3803		return graphql.Null
 3804	}
 3805	res := resTmp.(time.Time)
 3806	fc.Result = res
 3807	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3808}
 3809
 3810func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3811	defer func() {
 3812		if r := recover(); r != nil {
 3813			ec.Error(ctx, ec.Recover(ctx, r))
 3814			ret = graphql.Null
 3815		}
 3816	}()
 3817	fc := &graphql.FieldContext{
 3818		Object:   "Bug",
 3819		Field:    field,
 3820		Args:     nil,
 3821		IsMethod: true,
 3822	}
 3823
 3824	ctx = graphql.WithFieldContext(ctx, fc)
 3825	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3826		ctx = rctx // use context from middleware stack in children
 3827		return obj.LastEdit(), nil
 3828	})
 3829	if err != nil {
 3830		ec.Error(ctx, err)
 3831		return graphql.Null
 3832	}
 3833	if resTmp == nil {
 3834		if !graphql.HasFieldError(ctx, fc) {
 3835			ec.Errorf(ctx, "must not be null")
 3836		}
 3837		return graphql.Null
 3838	}
 3839	res := resTmp.(time.Time)
 3840	fc.Result = res
 3841	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3842}
 3843
 3844func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3845	defer func() {
 3846		if r := recover(); r != nil {
 3847			ec.Error(ctx, ec.Recover(ctx, r))
 3848			ret = graphql.Null
 3849		}
 3850	}()
 3851	fc := &graphql.FieldContext{
 3852		Object:   "Bug",
 3853		Field:    field,
 3854		Args:     nil,
 3855		IsMethod: true,
 3856	}
 3857
 3858	ctx = graphql.WithFieldContext(ctx, fc)
 3859	rawArgs := field.ArgumentMap(ec.Variables)
 3860	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3861	if err != nil {
 3862		ec.Error(ctx, err)
 3863		return graphql.Null
 3864	}
 3865	fc.Args = args
 3866	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3867		ctx = rctx // use context from middleware stack in children
 3868		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3869	})
 3870	if err != nil {
 3871		ec.Error(ctx, err)
 3872		return graphql.Null
 3873	}
 3874	if resTmp == nil {
 3875		if !graphql.HasFieldError(ctx, fc) {
 3876			ec.Errorf(ctx, "must not be null")
 3877		}
 3878		return graphql.Null
 3879	}
 3880	res := resTmp.(*models.IdentityConnection)
 3881	fc.Result = res
 3882	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3883}
 3884
 3885func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3886	defer func() {
 3887		if r := recover(); r != nil {
 3888			ec.Error(ctx, ec.Recover(ctx, r))
 3889			ret = graphql.Null
 3890		}
 3891	}()
 3892	fc := &graphql.FieldContext{
 3893		Object:   "Bug",
 3894		Field:    field,
 3895		Args:     nil,
 3896		IsMethod: true,
 3897	}
 3898
 3899	ctx = graphql.WithFieldContext(ctx, fc)
 3900	rawArgs := field.ArgumentMap(ec.Variables)
 3901	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3902	if err != nil {
 3903		ec.Error(ctx, err)
 3904		return graphql.Null
 3905	}
 3906	fc.Args = args
 3907	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3908		ctx = rctx // use context from middleware stack in children
 3909		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3910	})
 3911	if err != nil {
 3912		ec.Error(ctx, err)
 3913		return graphql.Null
 3914	}
 3915	if resTmp == nil {
 3916		if !graphql.HasFieldError(ctx, fc) {
 3917			ec.Errorf(ctx, "must not be null")
 3918		}
 3919		return graphql.Null
 3920	}
 3921	res := resTmp.(*models.IdentityConnection)
 3922	fc.Result = res
 3923	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3924}
 3925
 3926func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3927	defer func() {
 3928		if r := recover(); r != nil {
 3929			ec.Error(ctx, ec.Recover(ctx, r))
 3930			ret = graphql.Null
 3931		}
 3932	}()
 3933	fc := &graphql.FieldContext{
 3934		Object:   "Bug",
 3935		Field:    field,
 3936		Args:     nil,
 3937		IsMethod: true,
 3938	}
 3939
 3940	ctx = graphql.WithFieldContext(ctx, fc)
 3941	rawArgs := field.ArgumentMap(ec.Variables)
 3942	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3943	if err != nil {
 3944		ec.Error(ctx, err)
 3945		return graphql.Null
 3946	}
 3947	fc.Args = args
 3948	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3949		ctx = rctx // use context from middleware stack in children
 3950		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3951	})
 3952	if err != nil {
 3953		ec.Error(ctx, err)
 3954		return graphql.Null
 3955	}
 3956	if resTmp == nil {
 3957		if !graphql.HasFieldError(ctx, fc) {
 3958			ec.Errorf(ctx, "must not be null")
 3959		}
 3960		return graphql.Null
 3961	}
 3962	res := resTmp.(*models.CommentConnection)
 3963	fc.Result = res
 3964	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3965}
 3966
 3967func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3968	defer func() {
 3969		if r := recover(); r != nil {
 3970			ec.Error(ctx, ec.Recover(ctx, r))
 3971			ret = graphql.Null
 3972		}
 3973	}()
 3974	fc := &graphql.FieldContext{
 3975		Object:   "Bug",
 3976		Field:    field,
 3977		Args:     nil,
 3978		IsMethod: true,
 3979	}
 3980
 3981	ctx = graphql.WithFieldContext(ctx, fc)
 3982	rawArgs := field.ArgumentMap(ec.Variables)
 3983	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3984	if err != nil {
 3985		ec.Error(ctx, err)
 3986		return graphql.Null
 3987	}
 3988	fc.Args = args
 3989	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3990		ctx = rctx // use context from middleware stack in children
 3991		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3992	})
 3993	if err != nil {
 3994		ec.Error(ctx, err)
 3995		return graphql.Null
 3996	}
 3997	if resTmp == nil {
 3998		if !graphql.HasFieldError(ctx, fc) {
 3999			ec.Errorf(ctx, "must not be null")
 4000		}
 4001		return graphql.Null
 4002	}
 4003	res := resTmp.(*models.TimelineItemConnection)
 4004	fc.Result = res
 4005	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 4006}
 4007
 4008func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 4009	defer func() {
 4010		if r := recover(); r != nil {
 4011			ec.Error(ctx, ec.Recover(ctx, r))
 4012			ret = graphql.Null
 4013		}
 4014	}()
 4015	fc := &graphql.FieldContext{
 4016		Object:   "Bug",
 4017		Field:    field,
 4018		Args:     nil,
 4019		IsMethod: true,
 4020	}
 4021
 4022	ctx = graphql.WithFieldContext(ctx, fc)
 4023	rawArgs := field.ArgumentMap(ec.Variables)
 4024	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 4025	if err != nil {
 4026		ec.Error(ctx, err)
 4027		return graphql.Null
 4028	}
 4029	fc.Args = args
 4030	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4031		ctx = rctx // use context from middleware stack in children
 4032		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4033	})
 4034	if err != nil {
 4035		ec.Error(ctx, err)
 4036		return graphql.Null
 4037	}
 4038	if resTmp == nil {
 4039		if !graphql.HasFieldError(ctx, fc) {
 4040			ec.Errorf(ctx, "must not be null")
 4041		}
 4042		return graphql.Null
 4043	}
 4044	res := resTmp.(*models.OperationConnection)
 4045	fc.Result = res
 4046	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 4047}
 4048
 4049func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4050	defer func() {
 4051		if r := recover(); r != nil {
 4052			ec.Error(ctx, ec.Recover(ctx, r))
 4053			ret = graphql.Null
 4054		}
 4055	}()
 4056	fc := &graphql.FieldContext{
 4057		Object:   "BugConnection",
 4058		Field:    field,
 4059		Args:     nil,
 4060		IsMethod: false,
 4061	}
 4062
 4063	ctx = graphql.WithFieldContext(ctx, fc)
 4064	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4065		ctx = rctx // use context from middleware stack in children
 4066		return obj.Edges, nil
 4067	})
 4068	if err != nil {
 4069		ec.Error(ctx, err)
 4070		return graphql.Null
 4071	}
 4072	if resTmp == nil {
 4073		if !graphql.HasFieldError(ctx, fc) {
 4074			ec.Errorf(ctx, "must not be null")
 4075		}
 4076		return graphql.Null
 4077	}
 4078	res := resTmp.([]*models.BugEdge)
 4079	fc.Result = res
 4080	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 4081}
 4082
 4083func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4084	defer func() {
 4085		if r := recover(); r != nil {
 4086			ec.Error(ctx, ec.Recover(ctx, r))
 4087			ret = graphql.Null
 4088		}
 4089	}()
 4090	fc := &graphql.FieldContext{
 4091		Object:   "BugConnection",
 4092		Field:    field,
 4093		Args:     nil,
 4094		IsMethod: false,
 4095	}
 4096
 4097	ctx = graphql.WithFieldContext(ctx, fc)
 4098	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4099		ctx = rctx // use context from middleware stack in children
 4100		return obj.Nodes, nil
 4101	})
 4102	if err != nil {
 4103		ec.Error(ctx, err)
 4104		return graphql.Null
 4105	}
 4106	if resTmp == nil {
 4107		if !graphql.HasFieldError(ctx, fc) {
 4108			ec.Errorf(ctx, "must not be null")
 4109		}
 4110		return graphql.Null
 4111	}
 4112	res := resTmp.([]models.BugWrapper)
 4113	fc.Result = res
 4114	return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
 4115}
 4116
 4117func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4118	defer func() {
 4119		if r := recover(); r != nil {
 4120			ec.Error(ctx, ec.Recover(ctx, r))
 4121			ret = graphql.Null
 4122		}
 4123	}()
 4124	fc := &graphql.FieldContext{
 4125		Object:   "BugConnection",
 4126		Field:    field,
 4127		Args:     nil,
 4128		IsMethod: false,
 4129	}
 4130
 4131	ctx = graphql.WithFieldContext(ctx, fc)
 4132	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4133		ctx = rctx // use context from middleware stack in children
 4134		return obj.PageInfo, nil
 4135	})
 4136	if err != nil {
 4137		ec.Error(ctx, err)
 4138		return graphql.Null
 4139	}
 4140	if resTmp == nil {
 4141		if !graphql.HasFieldError(ctx, fc) {
 4142			ec.Errorf(ctx, "must not be null")
 4143		}
 4144		return graphql.Null
 4145	}
 4146	res := resTmp.(*models.PageInfo)
 4147	fc.Result = res
 4148	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4149}
 4150
 4151func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4152	defer func() {
 4153		if r := recover(); r != nil {
 4154			ec.Error(ctx, ec.Recover(ctx, r))
 4155			ret = graphql.Null
 4156		}
 4157	}()
 4158	fc := &graphql.FieldContext{
 4159		Object:   "BugConnection",
 4160		Field:    field,
 4161		Args:     nil,
 4162		IsMethod: false,
 4163	}
 4164
 4165	ctx = graphql.WithFieldContext(ctx, fc)
 4166	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4167		ctx = rctx // use context from middleware stack in children
 4168		return obj.TotalCount, nil
 4169	})
 4170	if err != nil {
 4171		ec.Error(ctx, err)
 4172		return graphql.Null
 4173	}
 4174	if resTmp == nil {
 4175		if !graphql.HasFieldError(ctx, fc) {
 4176			ec.Errorf(ctx, "must not be null")
 4177		}
 4178		return graphql.Null
 4179	}
 4180	res := resTmp.(int)
 4181	fc.Result = res
 4182	return ec.marshalNInt2int(ctx, field.Selections, res)
 4183}
 4184
 4185func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4186	defer func() {
 4187		if r := recover(); r != nil {
 4188			ec.Error(ctx, ec.Recover(ctx, r))
 4189			ret = graphql.Null
 4190		}
 4191	}()
 4192	fc := &graphql.FieldContext{
 4193		Object:   "BugEdge",
 4194		Field:    field,
 4195		Args:     nil,
 4196		IsMethod: false,
 4197	}
 4198
 4199	ctx = graphql.WithFieldContext(ctx, fc)
 4200	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4201		ctx = rctx // use context from middleware stack in children
 4202		return obj.Cursor, nil
 4203	})
 4204	if err != nil {
 4205		ec.Error(ctx, err)
 4206		return graphql.Null
 4207	}
 4208	if resTmp == nil {
 4209		if !graphql.HasFieldError(ctx, fc) {
 4210			ec.Errorf(ctx, "must not be null")
 4211		}
 4212		return graphql.Null
 4213	}
 4214	res := resTmp.(string)
 4215	fc.Result = res
 4216	return ec.marshalNString2string(ctx, field.Selections, res)
 4217}
 4218
 4219func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4220	defer func() {
 4221		if r := recover(); r != nil {
 4222			ec.Error(ctx, ec.Recover(ctx, r))
 4223			ret = graphql.Null
 4224		}
 4225	}()
 4226	fc := &graphql.FieldContext{
 4227		Object:   "BugEdge",
 4228		Field:    field,
 4229		Args:     nil,
 4230		IsMethod: false,
 4231	}
 4232
 4233	ctx = graphql.WithFieldContext(ctx, fc)
 4234	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4235		ctx = rctx // use context from middleware stack in children
 4236		return obj.Node, nil
 4237	})
 4238	if err != nil {
 4239		ec.Error(ctx, err)
 4240		return graphql.Null
 4241	}
 4242	if resTmp == nil {
 4243		if !graphql.HasFieldError(ctx, fc) {
 4244			ec.Errorf(ctx, "must not be null")
 4245		}
 4246		return graphql.Null
 4247	}
 4248	res := resTmp.(models.BugWrapper)
 4249	fc.Result = res
 4250	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4251}
 4252
 4253func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4254	defer func() {
 4255		if r := recover(); r != nil {
 4256			ec.Error(ctx, ec.Recover(ctx, r))
 4257			ret = graphql.Null
 4258		}
 4259	}()
 4260	fc := &graphql.FieldContext{
 4261		Object:   "ChangeLabelPayload",
 4262		Field:    field,
 4263		Args:     nil,
 4264		IsMethod: false,
 4265	}
 4266
 4267	ctx = graphql.WithFieldContext(ctx, fc)
 4268	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4269		ctx = rctx // use context from middleware stack in children
 4270		return obj.ClientMutationID, nil
 4271	})
 4272	if err != nil {
 4273		ec.Error(ctx, err)
 4274		return graphql.Null
 4275	}
 4276	if resTmp == nil {
 4277		return graphql.Null
 4278	}
 4279	res := resTmp.(*string)
 4280	fc.Result = res
 4281	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4282}
 4283
 4284func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4285	defer func() {
 4286		if r := recover(); r != nil {
 4287			ec.Error(ctx, ec.Recover(ctx, r))
 4288			ret = graphql.Null
 4289		}
 4290	}()
 4291	fc := &graphql.FieldContext{
 4292		Object:   "ChangeLabelPayload",
 4293		Field:    field,
 4294		Args:     nil,
 4295		IsMethod: false,
 4296	}
 4297
 4298	ctx = graphql.WithFieldContext(ctx, fc)
 4299	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4300		ctx = rctx // use context from middleware stack in children
 4301		return obj.Bug, nil
 4302	})
 4303	if err != nil {
 4304		ec.Error(ctx, err)
 4305		return graphql.Null
 4306	}
 4307	if resTmp == nil {
 4308		if !graphql.HasFieldError(ctx, fc) {
 4309			ec.Errorf(ctx, "must not be null")
 4310		}
 4311		return graphql.Null
 4312	}
 4313	res := resTmp.(models.BugWrapper)
 4314	fc.Result = res
 4315	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4316}
 4317
 4318func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4319	defer func() {
 4320		if r := recover(); r != nil {
 4321			ec.Error(ctx, ec.Recover(ctx, r))
 4322			ret = graphql.Null
 4323		}
 4324	}()
 4325	fc := &graphql.FieldContext{
 4326		Object:   "ChangeLabelPayload",
 4327		Field:    field,
 4328		Args:     nil,
 4329		IsMethod: false,
 4330	}
 4331
 4332	ctx = graphql.WithFieldContext(ctx, fc)
 4333	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4334		ctx = rctx // use context from middleware stack in children
 4335		return obj.Operation, nil
 4336	})
 4337	if err != nil {
 4338		ec.Error(ctx, err)
 4339		return graphql.Null
 4340	}
 4341	if resTmp == nil {
 4342		if !graphql.HasFieldError(ctx, fc) {
 4343			ec.Errorf(ctx, "must not be null")
 4344		}
 4345		return graphql.Null
 4346	}
 4347	res := resTmp.(*bug.LabelChangeOperation)
 4348	fc.Result = res
 4349	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4350}
 4351
 4352func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4353	defer func() {
 4354		if r := recover(); r != nil {
 4355			ec.Error(ctx, ec.Recover(ctx, r))
 4356			ret = graphql.Null
 4357		}
 4358	}()
 4359	fc := &graphql.FieldContext{
 4360		Object:   "ChangeLabelPayload",
 4361		Field:    field,
 4362		Args:     nil,
 4363		IsMethod: false,
 4364	}
 4365
 4366	ctx = graphql.WithFieldContext(ctx, fc)
 4367	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4368		ctx = rctx // use context from middleware stack in children
 4369		return obj.Results, nil
 4370	})
 4371	if err != nil {
 4372		ec.Error(ctx, err)
 4373		return graphql.Null
 4374	}
 4375	if resTmp == nil {
 4376		if !graphql.HasFieldError(ctx, fc) {
 4377			ec.Errorf(ctx, "must not be null")
 4378		}
 4379		return graphql.Null
 4380	}
 4381	res := resTmp.([]*bug.LabelChangeResult)
 4382	fc.Result = res
 4383	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4384}
 4385
 4386func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4387	defer func() {
 4388		if r := recover(); r != nil {
 4389			ec.Error(ctx, ec.Recover(ctx, r))
 4390			ret = graphql.Null
 4391		}
 4392	}()
 4393	fc := &graphql.FieldContext{
 4394		Object:   "CloseBugPayload",
 4395		Field:    field,
 4396		Args:     nil,
 4397		IsMethod: false,
 4398	}
 4399
 4400	ctx = graphql.WithFieldContext(ctx, fc)
 4401	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4402		ctx = rctx // use context from middleware stack in children
 4403		return obj.ClientMutationID, nil
 4404	})
 4405	if err != nil {
 4406		ec.Error(ctx, err)
 4407		return graphql.Null
 4408	}
 4409	if resTmp == nil {
 4410		return graphql.Null
 4411	}
 4412	res := resTmp.(*string)
 4413	fc.Result = res
 4414	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4415}
 4416
 4417func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4418	defer func() {
 4419		if r := recover(); r != nil {
 4420			ec.Error(ctx, ec.Recover(ctx, r))
 4421			ret = graphql.Null
 4422		}
 4423	}()
 4424	fc := &graphql.FieldContext{
 4425		Object:   "CloseBugPayload",
 4426		Field:    field,
 4427		Args:     nil,
 4428		IsMethod: false,
 4429	}
 4430
 4431	ctx = graphql.WithFieldContext(ctx, fc)
 4432	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4433		ctx = rctx // use context from middleware stack in children
 4434		return obj.Bug, nil
 4435	})
 4436	if err != nil {
 4437		ec.Error(ctx, err)
 4438		return graphql.Null
 4439	}
 4440	if resTmp == nil {
 4441		if !graphql.HasFieldError(ctx, fc) {
 4442			ec.Errorf(ctx, "must not be null")
 4443		}
 4444		return graphql.Null
 4445	}
 4446	res := resTmp.(models.BugWrapper)
 4447	fc.Result = res
 4448	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4449}
 4450
 4451func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4452	defer func() {
 4453		if r := recover(); r != nil {
 4454			ec.Error(ctx, ec.Recover(ctx, r))
 4455			ret = graphql.Null
 4456		}
 4457	}()
 4458	fc := &graphql.FieldContext{
 4459		Object:   "CloseBugPayload",
 4460		Field:    field,
 4461		Args:     nil,
 4462		IsMethod: false,
 4463	}
 4464
 4465	ctx = graphql.WithFieldContext(ctx, fc)
 4466	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4467		ctx = rctx // use context from middleware stack in children
 4468		return obj.Operation, nil
 4469	})
 4470	if err != nil {
 4471		ec.Error(ctx, err)
 4472		return graphql.Null
 4473	}
 4474	if resTmp == nil {
 4475		if !graphql.HasFieldError(ctx, fc) {
 4476			ec.Errorf(ctx, "must not be null")
 4477		}
 4478		return graphql.Null
 4479	}
 4480	res := resTmp.(*bug.SetStatusOperation)
 4481	fc.Result = res
 4482	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4483}
 4484
 4485func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4486	defer func() {
 4487		if r := recover(); r != nil {
 4488			ec.Error(ctx, ec.Recover(ctx, r))
 4489			ret = graphql.Null
 4490		}
 4491	}()
 4492	fc := &graphql.FieldContext{
 4493		Object:   "Color",
 4494		Field:    field,
 4495		Args:     nil,
 4496		IsMethod: true,
 4497	}
 4498
 4499	ctx = graphql.WithFieldContext(ctx, fc)
 4500	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4501		ctx = rctx // use context from middleware stack in children
 4502		return ec.resolvers.Color().R(rctx, obj)
 4503	})
 4504	if err != nil {
 4505		ec.Error(ctx, err)
 4506		return graphql.Null
 4507	}
 4508	if resTmp == nil {
 4509		if !graphql.HasFieldError(ctx, fc) {
 4510			ec.Errorf(ctx, "must not be null")
 4511		}
 4512		return graphql.Null
 4513	}
 4514	res := resTmp.(int)
 4515	fc.Result = res
 4516	return ec.marshalNInt2int(ctx, field.Selections, res)
 4517}
 4518
 4519func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4520	defer func() {
 4521		if r := recover(); r != nil {
 4522			ec.Error(ctx, ec.Recover(ctx, r))
 4523			ret = graphql.Null
 4524		}
 4525	}()
 4526	fc := &graphql.FieldContext{
 4527		Object:   "Color",
 4528		Field:    field,
 4529		Args:     nil,
 4530		IsMethod: true,
 4531	}
 4532
 4533	ctx = graphql.WithFieldContext(ctx, fc)
 4534	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4535		ctx = rctx // use context from middleware stack in children
 4536		return ec.resolvers.Color().G(rctx, obj)
 4537	})
 4538	if err != nil {
 4539		ec.Error(ctx, err)
 4540		return graphql.Null
 4541	}
 4542	if resTmp == nil {
 4543		if !graphql.HasFieldError(ctx, fc) {
 4544			ec.Errorf(ctx, "must not be null")
 4545		}
 4546		return graphql.Null
 4547	}
 4548	res := resTmp.(int)
 4549	fc.Result = res
 4550	return ec.marshalNInt2int(ctx, field.Selections, res)
 4551}
 4552
 4553func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4554	defer func() {
 4555		if r := recover(); r != nil {
 4556			ec.Error(ctx, ec.Recover(ctx, r))
 4557			ret = graphql.Null
 4558		}
 4559	}()
 4560	fc := &graphql.FieldContext{
 4561		Object:   "Color",
 4562		Field:    field,
 4563		Args:     nil,
 4564		IsMethod: true,
 4565	}
 4566
 4567	ctx = graphql.WithFieldContext(ctx, fc)
 4568	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4569		ctx = rctx // use context from middleware stack in children
 4570		return ec.resolvers.Color().B(rctx, obj)
 4571	})
 4572	if err != nil {
 4573		ec.Error(ctx, err)
 4574		return graphql.Null
 4575	}
 4576	if resTmp == nil {
 4577		if !graphql.HasFieldError(ctx, fc) {
 4578			ec.Errorf(ctx, "must not be null")
 4579		}
 4580		return graphql.Null
 4581	}
 4582	res := resTmp.(int)
 4583	fc.Result = res
 4584	return ec.marshalNInt2int(ctx, field.Selections, res)
 4585}
 4586
 4587func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4588	defer func() {
 4589		if r := recover(); r != nil {
 4590			ec.Error(ctx, ec.Recover(ctx, r))
 4591			ret = graphql.Null
 4592		}
 4593	}()
 4594	fc := &graphql.FieldContext{
 4595		Object:   "Comment",
 4596		Field:    field,
 4597		Args:     nil,
 4598		IsMethod: true,
 4599	}
 4600
 4601	ctx = graphql.WithFieldContext(ctx, fc)
 4602	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4603		ctx = rctx // use context from middleware stack in children
 4604		return ec.resolvers.Comment().Author(rctx, obj)
 4605	})
 4606	if err != nil {
 4607		ec.Error(ctx, err)
 4608		return graphql.Null
 4609	}
 4610	if resTmp == nil {
 4611		if !graphql.HasFieldError(ctx, fc) {
 4612			ec.Errorf(ctx, "must not be null")
 4613		}
 4614		return graphql.Null
 4615	}
 4616	res := resTmp.(models.IdentityWrapper)
 4617	fc.Result = res
 4618	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4619}
 4620
 4621func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4622	defer func() {
 4623		if r := recover(); r != nil {
 4624			ec.Error(ctx, ec.Recover(ctx, r))
 4625			ret = graphql.Null
 4626		}
 4627	}()
 4628	fc := &graphql.FieldContext{
 4629		Object:   "Comment",
 4630		Field:    field,
 4631		Args:     nil,
 4632		IsMethod: false,
 4633	}
 4634
 4635	ctx = graphql.WithFieldContext(ctx, fc)
 4636	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4637		ctx = rctx // use context from middleware stack in children
 4638		return obj.Message, nil
 4639	})
 4640	if err != nil {
 4641		ec.Error(ctx, err)
 4642		return graphql.Null
 4643	}
 4644	if resTmp == nil {
 4645		if !graphql.HasFieldError(ctx, fc) {
 4646			ec.Errorf(ctx, "must not be null")
 4647		}
 4648		return graphql.Null
 4649	}
 4650	res := resTmp.(string)
 4651	fc.Result = res
 4652	return ec.marshalNString2string(ctx, field.Selections, res)
 4653}
 4654
 4655func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4656	defer func() {
 4657		if r := recover(); r != nil {
 4658			ec.Error(ctx, ec.Recover(ctx, r))
 4659			ret = graphql.Null
 4660		}
 4661	}()
 4662	fc := &graphql.FieldContext{
 4663		Object:   "Comment",
 4664		Field:    field,
 4665		Args:     nil,
 4666		IsMethod: false,
 4667	}
 4668
 4669	ctx = graphql.WithFieldContext(ctx, fc)
 4670	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4671		ctx = rctx // use context from middleware stack in children
 4672		return obj.Files, nil
 4673	})
 4674	if err != nil {
 4675		ec.Error(ctx, err)
 4676		return graphql.Null
 4677	}
 4678	if resTmp == nil {
 4679		if !graphql.HasFieldError(ctx, fc) {
 4680			ec.Errorf(ctx, "must not be null")
 4681		}
 4682		return graphql.Null
 4683	}
 4684	res := resTmp.([]repository.Hash)
 4685	fc.Result = res
 4686	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 4687}
 4688
 4689func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4690	defer func() {
 4691		if r := recover(); r != nil {
 4692			ec.Error(ctx, ec.Recover(ctx, r))
 4693			ret = graphql.Null
 4694		}
 4695	}()
 4696	fc := &graphql.FieldContext{
 4697		Object:   "CommentConnection",
 4698		Field:    field,
 4699		Args:     nil,
 4700		IsMethod: false,
 4701	}
 4702
 4703	ctx = graphql.WithFieldContext(ctx, fc)
 4704	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4705		ctx = rctx // use context from middleware stack in children
 4706		return obj.Edges, nil
 4707	})
 4708	if err != nil {
 4709		ec.Error(ctx, err)
 4710		return graphql.Null
 4711	}
 4712	if resTmp == nil {
 4713		if !graphql.HasFieldError(ctx, fc) {
 4714			ec.Errorf(ctx, "must not be null")
 4715		}
 4716		return graphql.Null
 4717	}
 4718	res := resTmp.([]*models.CommentEdge)
 4719	fc.Result = res
 4720	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4721}
 4722
 4723func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4724	defer func() {
 4725		if r := recover(); r != nil {
 4726			ec.Error(ctx, ec.Recover(ctx, r))
 4727			ret = graphql.Null
 4728		}
 4729	}()
 4730	fc := &graphql.FieldContext{
 4731		Object:   "CommentConnection",
 4732		Field:    field,
 4733		Args:     nil,
 4734		IsMethod: false,
 4735	}
 4736
 4737	ctx = graphql.WithFieldContext(ctx, fc)
 4738	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4739		ctx = rctx // use context from middleware stack in children
 4740		return obj.Nodes, nil
 4741	})
 4742	if err != nil {
 4743		ec.Error(ctx, err)
 4744		return graphql.Null
 4745	}
 4746	if resTmp == nil {
 4747		if !graphql.HasFieldError(ctx, fc) {
 4748			ec.Errorf(ctx, "must not be null")
 4749		}
 4750		return graphql.Null
 4751	}
 4752	res := resTmp.([]*bug.Comment)
 4753	fc.Result = res
 4754	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 4755}
 4756
 4757func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4758	defer func() {
 4759		if r := recover(); r != nil {
 4760			ec.Error(ctx, ec.Recover(ctx, r))
 4761			ret = graphql.Null
 4762		}
 4763	}()
 4764	fc := &graphql.FieldContext{
 4765		Object:   "CommentConnection",
 4766		Field:    field,
 4767		Args:     nil,
 4768		IsMethod: false,
 4769	}
 4770
 4771	ctx = graphql.WithFieldContext(ctx, fc)
 4772	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4773		ctx = rctx // use context from middleware stack in children
 4774		return obj.PageInfo, nil
 4775	})
 4776	if err != nil {
 4777		ec.Error(ctx, err)
 4778		return graphql.Null
 4779	}
 4780	if resTmp == nil {
 4781		if !graphql.HasFieldError(ctx, fc) {
 4782			ec.Errorf(ctx, "must not be null")
 4783		}
 4784		return graphql.Null
 4785	}
 4786	res := resTmp.(*models.PageInfo)
 4787	fc.Result = res
 4788	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4789}
 4790
 4791func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4792	defer func() {
 4793		if r := recover(); r != nil {
 4794			ec.Error(ctx, ec.Recover(ctx, r))
 4795			ret = graphql.Null
 4796		}
 4797	}()
 4798	fc := &graphql.FieldContext{
 4799		Object:   "CommentConnection",
 4800		Field:    field,
 4801		Args:     nil,
 4802		IsMethod: false,
 4803	}
 4804
 4805	ctx = graphql.WithFieldContext(ctx, fc)
 4806	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4807		ctx = rctx // use context from middleware stack in children
 4808		return obj.TotalCount, nil
 4809	})
 4810	if err != nil {
 4811		ec.Error(ctx, err)
 4812		return graphql.Null
 4813	}
 4814	if resTmp == nil {
 4815		if !graphql.HasFieldError(ctx, fc) {
 4816			ec.Errorf(ctx, "must not be null")
 4817		}
 4818		return graphql.Null
 4819	}
 4820	res := resTmp.(int)
 4821	fc.Result = res
 4822	return ec.marshalNInt2int(ctx, field.Selections, res)
 4823}
 4824
 4825func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4826	defer func() {
 4827		if r := recover(); r != nil {
 4828			ec.Error(ctx, ec.Recover(ctx, r))
 4829			ret = graphql.Null
 4830		}
 4831	}()
 4832	fc := &graphql.FieldContext{
 4833		Object:   "CommentEdge",
 4834		Field:    field,
 4835		Args:     nil,
 4836		IsMethod: false,
 4837	}
 4838
 4839	ctx = graphql.WithFieldContext(ctx, fc)
 4840	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4841		ctx = rctx // use context from middleware stack in children
 4842		return obj.Cursor, nil
 4843	})
 4844	if err != nil {
 4845		ec.Error(ctx, err)
 4846		return graphql.Null
 4847	}
 4848	if resTmp == nil {
 4849		if !graphql.HasFieldError(ctx, fc) {
 4850			ec.Errorf(ctx, "must not be null")
 4851		}
 4852		return graphql.Null
 4853	}
 4854	res := resTmp.(string)
 4855	fc.Result = res
 4856	return ec.marshalNString2string(ctx, field.Selections, res)
 4857}
 4858
 4859func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4860	defer func() {
 4861		if r := recover(); r != nil {
 4862			ec.Error(ctx, ec.Recover(ctx, r))
 4863			ret = graphql.Null
 4864		}
 4865	}()
 4866	fc := &graphql.FieldContext{
 4867		Object:   "CommentEdge",
 4868		Field:    field,
 4869		Args:     nil,
 4870		IsMethod: false,
 4871	}
 4872
 4873	ctx = graphql.WithFieldContext(ctx, fc)
 4874	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4875		ctx = rctx // use context from middleware stack in children
 4876		return obj.Node, nil
 4877	})
 4878	if err != nil {
 4879		ec.Error(ctx, err)
 4880		return graphql.Null
 4881	}
 4882	if resTmp == nil {
 4883		if !graphql.HasFieldError(ctx, fc) {
 4884			ec.Errorf(ctx, "must not be null")
 4885		}
 4886		return graphql.Null
 4887	}
 4888	res := resTmp.(*bug.Comment)
 4889	fc.Result = res
 4890	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4891}
 4892
 4893func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4894	defer func() {
 4895		if r := recover(); r != nil {
 4896			ec.Error(ctx, ec.Recover(ctx, r))
 4897			ret = graphql.Null
 4898		}
 4899	}()
 4900	fc := &graphql.FieldContext{
 4901		Object:   "CommentHistoryStep",
 4902		Field:    field,
 4903		Args:     nil,
 4904		IsMethod: false,
 4905	}
 4906
 4907	ctx = graphql.WithFieldContext(ctx, fc)
 4908	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4909		ctx = rctx // use context from middleware stack in children
 4910		return obj.Message, nil
 4911	})
 4912	if err != nil {
 4913		ec.Error(ctx, err)
 4914		return graphql.Null
 4915	}
 4916	if resTmp == nil {
 4917		if !graphql.HasFieldError(ctx, fc) {
 4918			ec.Errorf(ctx, "must not be null")
 4919		}
 4920		return graphql.Null
 4921	}
 4922	res := resTmp.(string)
 4923	fc.Result = res
 4924	return ec.marshalNString2string(ctx, field.Selections, res)
 4925}
 4926
 4927func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4928	defer func() {
 4929		if r := recover(); r != nil {
 4930			ec.Error(ctx, ec.Recover(ctx, r))
 4931			ret = graphql.Null
 4932		}
 4933	}()
 4934	fc := &graphql.FieldContext{
 4935		Object:   "CommentHistoryStep",
 4936		Field:    field,
 4937		Args:     nil,
 4938		IsMethod: true,
 4939	}
 4940
 4941	ctx = graphql.WithFieldContext(ctx, fc)
 4942	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4943		ctx = rctx // use context from middleware stack in children
 4944		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4945	})
 4946	if err != nil {
 4947		ec.Error(ctx, err)
 4948		return graphql.Null
 4949	}
 4950	if resTmp == nil {
 4951		if !graphql.HasFieldError(ctx, fc) {
 4952			ec.Errorf(ctx, "must not be null")
 4953		}
 4954		return graphql.Null
 4955	}
 4956	res := resTmp.(*time.Time)
 4957	fc.Result = res
 4958	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4959}
 4960
 4961func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4962	defer func() {
 4963		if r := recover(); r != nil {
 4964			ec.Error(ctx, ec.Recover(ctx, r))
 4965			ret = graphql.Null
 4966		}
 4967	}()
 4968	fc := &graphql.FieldContext{
 4969		Object:   "CreateOperation",
 4970		Field:    field,
 4971		Args:     nil,
 4972		IsMethod: true,
 4973	}
 4974
 4975	ctx = graphql.WithFieldContext(ctx, fc)
 4976	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4977		ctx = rctx // use context from middleware stack in children
 4978		return ec.resolvers.CreateOperation().ID(rctx, obj)
 4979	})
 4980	if err != nil {
 4981		ec.Error(ctx, err)
 4982		return graphql.Null
 4983	}
 4984	if resTmp == nil {
 4985		if !graphql.HasFieldError(ctx, fc) {
 4986			ec.Errorf(ctx, "must not be null")
 4987		}
 4988		return graphql.Null
 4989	}
 4990	res := resTmp.(string)
 4991	fc.Result = res
 4992	return ec.marshalNString2string(ctx, field.Selections, res)
 4993}
 4994
 4995func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 4996	defer func() {
 4997		if r := recover(); r != nil {
 4998			ec.Error(ctx, ec.Recover(ctx, r))
 4999			ret = graphql.Null
 5000		}
 5001	}()
 5002	fc := &graphql.FieldContext{
 5003		Object:   "CreateOperation",
 5004		Field:    field,
 5005		Args:     nil,
 5006		IsMethod: true,
 5007	}
 5008
 5009	ctx = graphql.WithFieldContext(ctx, fc)
 5010	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5011		ctx = rctx // use context from middleware stack in children
 5012		return ec.resolvers.CreateOperation().Author(rctx, obj)
 5013	})
 5014	if err != nil {
 5015		ec.Error(ctx, err)
 5016		return graphql.Null
 5017	}
 5018	if resTmp == nil {
 5019		if !graphql.HasFieldError(ctx, fc) {
 5020			ec.Errorf(ctx, "must not be null")
 5021		}
 5022		return graphql.Null
 5023	}
 5024	res := resTmp.(models.IdentityWrapper)
 5025	fc.Result = res
 5026	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5027}
 5028
 5029func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5030	defer func() {
 5031		if r := recover(); r != nil {
 5032			ec.Error(ctx, ec.Recover(ctx, r))
 5033			ret = graphql.Null
 5034		}
 5035	}()
 5036	fc := &graphql.FieldContext{
 5037		Object:   "CreateOperation",
 5038		Field:    field,
 5039		Args:     nil,
 5040		IsMethod: true,
 5041	}
 5042
 5043	ctx = graphql.WithFieldContext(ctx, fc)
 5044	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5045		ctx = rctx // use context from middleware stack in children
 5046		return ec.resolvers.CreateOperation().Date(rctx, obj)
 5047	})
 5048	if err != nil {
 5049		ec.Error(ctx, err)
 5050		return graphql.Null
 5051	}
 5052	if resTmp == nil {
 5053		if !graphql.HasFieldError(ctx, fc) {
 5054			ec.Errorf(ctx, "must not be null")
 5055		}
 5056		return graphql.Null
 5057	}
 5058	res := resTmp.(*time.Time)
 5059	fc.Result = res
 5060	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5061}
 5062
 5063func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5064	defer func() {
 5065		if r := recover(); r != nil {
 5066			ec.Error(ctx, ec.Recover(ctx, r))
 5067			ret = graphql.Null
 5068		}
 5069	}()
 5070	fc := &graphql.FieldContext{
 5071		Object:   "CreateOperation",
 5072		Field:    field,
 5073		Args:     nil,
 5074		IsMethod: false,
 5075	}
 5076
 5077	ctx = graphql.WithFieldContext(ctx, fc)
 5078	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5079		ctx = rctx // use context from middleware stack in children
 5080		return obj.Title, nil
 5081	})
 5082	if err != nil {
 5083		ec.Error(ctx, err)
 5084		return graphql.Null
 5085	}
 5086	if resTmp == nil {
 5087		if !graphql.HasFieldError(ctx, fc) {
 5088			ec.Errorf(ctx, "must not be null")
 5089		}
 5090		return graphql.Null
 5091	}
 5092	res := resTmp.(string)
 5093	fc.Result = res
 5094	return ec.marshalNString2string(ctx, field.Selections, res)
 5095}
 5096
 5097func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5098	defer func() {
 5099		if r := recover(); r != nil {
 5100			ec.Error(ctx, ec.Recover(ctx, r))
 5101			ret = graphql.Null
 5102		}
 5103	}()
 5104	fc := &graphql.FieldContext{
 5105		Object:   "CreateOperation",
 5106		Field:    field,
 5107		Args:     nil,
 5108		IsMethod: false,
 5109	}
 5110
 5111	ctx = graphql.WithFieldContext(ctx, fc)
 5112	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5113		ctx = rctx // use context from middleware stack in children
 5114		return obj.Message, nil
 5115	})
 5116	if err != nil {
 5117		ec.Error(ctx, err)
 5118		return graphql.Null
 5119	}
 5120	if resTmp == nil {
 5121		if !graphql.HasFieldError(ctx, fc) {
 5122			ec.Errorf(ctx, "must not be null")
 5123		}
 5124		return graphql.Null
 5125	}
 5126	res := resTmp.(string)
 5127	fc.Result = res
 5128	return ec.marshalNString2string(ctx, field.Selections, res)
 5129}
 5130
 5131func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5132	defer func() {
 5133		if r := recover(); r != nil {
 5134			ec.Error(ctx, ec.Recover(ctx, r))
 5135			ret = graphql.Null
 5136		}
 5137	}()
 5138	fc := &graphql.FieldContext{
 5139		Object:   "CreateOperation",
 5140		Field:    field,
 5141		Args:     nil,
 5142		IsMethod: false,
 5143	}
 5144
 5145	ctx = graphql.WithFieldContext(ctx, fc)
 5146	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5147		ctx = rctx // use context from middleware stack in children
 5148		return obj.Files, nil
 5149	})
 5150	if err != nil {
 5151		ec.Error(ctx, err)
 5152		return graphql.Null
 5153	}
 5154	if resTmp == nil {
 5155		if !graphql.HasFieldError(ctx, fc) {
 5156			ec.Errorf(ctx, "must not be null")
 5157		}
 5158		return graphql.Null
 5159	}
 5160	res := resTmp.([]repository.Hash)
 5161	fc.Result = res
 5162	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 5163}
 5164
 5165func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5166	defer func() {
 5167		if r := recover(); r != nil {
 5168			ec.Error(ctx, ec.Recover(ctx, r))
 5169			ret = graphql.Null
 5170		}
 5171	}()
 5172	fc := &graphql.FieldContext{
 5173		Object:   "CreateTimelineItem",
 5174		Field:    field,
 5175		Args:     nil,
 5176		IsMethod: true,
 5177	}
 5178
 5179	ctx = graphql.WithFieldContext(ctx, fc)
 5180	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5181		ctx = rctx // use context from middleware stack in children
 5182		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5183	})
 5184	if err != nil {
 5185		ec.Error(ctx, err)
 5186		return graphql.Null
 5187	}
 5188	if resTmp == nil {
 5189		if !graphql.HasFieldError(ctx, fc) {
 5190			ec.Errorf(ctx, "must not be null")
 5191		}
 5192		return graphql.Null
 5193	}
 5194	res := resTmp.(string)
 5195	fc.Result = res
 5196	return ec.marshalNString2string(ctx, field.Selections, res)
 5197}
 5198
 5199func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5200	defer func() {
 5201		if r := recover(); r != nil {
 5202			ec.Error(ctx, ec.Recover(ctx, r))
 5203			ret = graphql.Null
 5204		}
 5205	}()
 5206	fc := &graphql.FieldContext{
 5207		Object:   "CreateTimelineItem",
 5208		Field:    field,
 5209		Args:     nil,
 5210		IsMethod: true,
 5211	}
 5212
 5213	ctx = graphql.WithFieldContext(ctx, fc)
 5214	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5215		ctx = rctx // use context from middleware stack in children
 5216		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
 5217	})
 5218	if err != nil {
 5219		ec.Error(ctx, err)
 5220		return graphql.Null
 5221	}
 5222	if resTmp == nil {
 5223		if !graphql.HasFieldError(ctx, fc) {
 5224			ec.Errorf(ctx, "must not be null")
 5225		}
 5226		return graphql.Null
 5227	}
 5228	res := resTmp.(models.IdentityWrapper)
 5229	fc.Result = res
 5230	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5231}
 5232
 5233func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5234	defer func() {
 5235		if r := recover(); r != nil {
 5236			ec.Error(ctx, ec.Recover(ctx, r))
 5237			ret = graphql.Null
 5238		}
 5239	}()
 5240	fc := &graphql.FieldContext{
 5241		Object:   "CreateTimelineItem",
 5242		Field:    field,
 5243		Args:     nil,
 5244		IsMethod: false,
 5245	}
 5246
 5247	ctx = graphql.WithFieldContext(ctx, fc)
 5248	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5249		ctx = rctx // use context from middleware stack in children
 5250		return obj.Message, nil
 5251	})
 5252	if err != nil {
 5253		ec.Error(ctx, err)
 5254		return graphql.Null
 5255	}
 5256	if resTmp == nil {
 5257		if !graphql.HasFieldError(ctx, fc) {
 5258			ec.Errorf(ctx, "must not be null")
 5259		}
 5260		return graphql.Null
 5261	}
 5262	res := resTmp.(string)
 5263	fc.Result = res
 5264	return ec.marshalNString2string(ctx, field.Selections, res)
 5265}
 5266
 5267func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5268	defer func() {
 5269		if r := recover(); r != nil {
 5270			ec.Error(ctx, ec.Recover(ctx, r))
 5271			ret = graphql.Null
 5272		}
 5273	}()
 5274	fc := &graphql.FieldContext{
 5275		Object:   "CreateTimelineItem",
 5276		Field:    field,
 5277		Args:     nil,
 5278		IsMethod: true,
 5279	}
 5280
 5281	ctx = graphql.WithFieldContext(ctx, fc)
 5282	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5283		ctx = rctx // use context from middleware stack in children
 5284		return obj.MessageIsEmpty(), nil
 5285	})
 5286	if err != nil {
 5287		ec.Error(ctx, err)
 5288		return graphql.Null
 5289	}
 5290	if resTmp == nil {
 5291		if !graphql.HasFieldError(ctx, fc) {
 5292			ec.Errorf(ctx, "must not be null")
 5293		}
 5294		return graphql.Null
 5295	}
 5296	res := resTmp.(bool)
 5297	fc.Result = res
 5298	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5299}
 5300
 5301func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5302	defer func() {
 5303		if r := recover(); r != nil {
 5304			ec.Error(ctx, ec.Recover(ctx, r))
 5305			ret = graphql.Null
 5306		}
 5307	}()
 5308	fc := &graphql.FieldContext{
 5309		Object:   "CreateTimelineItem",
 5310		Field:    field,
 5311		Args:     nil,
 5312		IsMethod: false,
 5313	}
 5314
 5315	ctx = graphql.WithFieldContext(ctx, fc)
 5316	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5317		ctx = rctx // use context from middleware stack in children
 5318		return obj.Files, nil
 5319	})
 5320	if err != nil {
 5321		ec.Error(ctx, err)
 5322		return graphql.Null
 5323	}
 5324	if resTmp == nil {
 5325		if !graphql.HasFieldError(ctx, fc) {
 5326			ec.Errorf(ctx, "must not be null")
 5327		}
 5328		return graphql.Null
 5329	}
 5330	res := resTmp.([]repository.Hash)
 5331	fc.Result = res
 5332	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 5333}
 5334
 5335func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5336	defer func() {
 5337		if r := recover(); r != nil {
 5338			ec.Error(ctx, ec.Recover(ctx, r))
 5339			ret = graphql.Null
 5340		}
 5341	}()
 5342	fc := &graphql.FieldContext{
 5343		Object:   "CreateTimelineItem",
 5344		Field:    field,
 5345		Args:     nil,
 5346		IsMethod: true,
 5347	}
 5348
 5349	ctx = graphql.WithFieldContext(ctx, fc)
 5350	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5351		ctx = rctx // use context from middleware stack in children
 5352		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5353	})
 5354	if err != nil {
 5355		ec.Error(ctx, err)
 5356		return graphql.Null
 5357	}
 5358	if resTmp == nil {
 5359		if !graphql.HasFieldError(ctx, fc) {
 5360			ec.Errorf(ctx, "must not be null")
 5361		}
 5362		return graphql.Null
 5363	}
 5364	res := resTmp.(*time.Time)
 5365	fc.Result = res
 5366	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5367}
 5368
 5369func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5370	defer func() {
 5371		if r := recover(); r != nil {
 5372			ec.Error(ctx, ec.Recover(ctx, r))
 5373			ret = graphql.Null
 5374		}
 5375	}()
 5376	fc := &graphql.FieldContext{
 5377		Object:   "CreateTimelineItem",
 5378		Field:    field,
 5379		Args:     nil,
 5380		IsMethod: true,
 5381	}
 5382
 5383	ctx = graphql.WithFieldContext(ctx, fc)
 5384	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5385		ctx = rctx // use context from middleware stack in children
 5386		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5387	})
 5388	if err != nil {
 5389		ec.Error(ctx, err)
 5390		return graphql.Null
 5391	}
 5392	if resTmp == nil {
 5393		if !graphql.HasFieldError(ctx, fc) {
 5394			ec.Errorf(ctx, "must not be null")
 5395		}
 5396		return graphql.Null
 5397	}
 5398	res := resTmp.(*time.Time)
 5399	fc.Result = res
 5400	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5401}
 5402
 5403func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5404	defer func() {
 5405		if r := recover(); r != nil {
 5406			ec.Error(ctx, ec.Recover(ctx, r))
 5407			ret = graphql.Null
 5408		}
 5409	}()
 5410	fc := &graphql.FieldContext{
 5411		Object:   "CreateTimelineItem",
 5412		Field:    field,
 5413		Args:     nil,
 5414		IsMethod: true,
 5415	}
 5416
 5417	ctx = graphql.WithFieldContext(ctx, fc)
 5418	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5419		ctx = rctx // use context from middleware stack in children
 5420		return obj.Edited(), nil
 5421	})
 5422	if err != nil {
 5423		ec.Error(ctx, err)
 5424		return graphql.Null
 5425	}
 5426	if resTmp == nil {
 5427		if !graphql.HasFieldError(ctx, fc) {
 5428			ec.Errorf(ctx, "must not be null")
 5429		}
 5430		return graphql.Null
 5431	}
 5432	res := resTmp.(bool)
 5433	fc.Result = res
 5434	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5435}
 5436
 5437func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5438	defer func() {
 5439		if r := recover(); r != nil {
 5440			ec.Error(ctx, ec.Recover(ctx, r))
 5441			ret = graphql.Null
 5442		}
 5443	}()
 5444	fc := &graphql.FieldContext{
 5445		Object:   "CreateTimelineItem",
 5446		Field:    field,
 5447		Args:     nil,
 5448		IsMethod: false,
 5449	}
 5450
 5451	ctx = graphql.WithFieldContext(ctx, fc)
 5452	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5453		ctx = rctx // use context from middleware stack in children
 5454		return obj.History, nil
 5455	})
 5456	if err != nil {
 5457		ec.Error(ctx, err)
 5458		return graphql.Null
 5459	}
 5460	if resTmp == nil {
 5461		if !graphql.HasFieldError(ctx, fc) {
 5462			ec.Errorf(ctx, "must not be null")
 5463		}
 5464		return graphql.Null
 5465	}
 5466	res := resTmp.([]bug.CommentHistoryStep)
 5467	fc.Result = res
 5468	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5469}
 5470
 5471func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5472	defer func() {
 5473		if r := recover(); r != nil {
 5474			ec.Error(ctx, ec.Recover(ctx, r))
 5475			ret = graphql.Null
 5476		}
 5477	}()
 5478	fc := &graphql.FieldContext{
 5479		Object:   "EditCommentOperation",
 5480		Field:    field,
 5481		Args:     nil,
 5482		IsMethod: true,
 5483	}
 5484
 5485	ctx = graphql.WithFieldContext(ctx, fc)
 5486	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5487		ctx = rctx // use context from middleware stack in children
 5488		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5489	})
 5490	if err != nil {
 5491		ec.Error(ctx, err)
 5492		return graphql.Null
 5493	}
 5494	if resTmp == nil {
 5495		if !graphql.HasFieldError(ctx, fc) {
 5496			ec.Errorf(ctx, "must not be null")
 5497		}
 5498		return graphql.Null
 5499	}
 5500	res := resTmp.(string)
 5501	fc.Result = res
 5502	return ec.marshalNString2string(ctx, field.Selections, res)
 5503}
 5504
 5505func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5506	defer func() {
 5507		if r := recover(); r != nil {
 5508			ec.Error(ctx, ec.Recover(ctx, r))
 5509			ret = graphql.Null
 5510		}
 5511	}()
 5512	fc := &graphql.FieldContext{
 5513		Object:   "EditCommentOperation",
 5514		Field:    field,
 5515		Args:     nil,
 5516		IsMethod: true,
 5517	}
 5518
 5519	ctx = graphql.WithFieldContext(ctx, fc)
 5520	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5521		ctx = rctx // use context from middleware stack in children
 5522		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
 5523	})
 5524	if err != nil {
 5525		ec.Error(ctx, err)
 5526		return graphql.Null
 5527	}
 5528	if resTmp == nil {
 5529		if !graphql.HasFieldError(ctx, fc) {
 5530			ec.Errorf(ctx, "must not be null")
 5531		}
 5532		return graphql.Null
 5533	}
 5534	res := resTmp.(models.IdentityWrapper)
 5535	fc.Result = res
 5536	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5537}
 5538
 5539func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5540	defer func() {
 5541		if r := recover(); r != nil {
 5542			ec.Error(ctx, ec.Recover(ctx, r))
 5543			ret = graphql.Null
 5544		}
 5545	}()
 5546	fc := &graphql.FieldContext{
 5547		Object:   "EditCommentOperation",
 5548		Field:    field,
 5549		Args:     nil,
 5550		IsMethod: true,
 5551	}
 5552
 5553	ctx = graphql.WithFieldContext(ctx, fc)
 5554	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5555		ctx = rctx // use context from middleware stack in children
 5556		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5557	})
 5558	if err != nil {
 5559		ec.Error(ctx, err)
 5560		return graphql.Null
 5561	}
 5562	if resTmp == nil {
 5563		if !graphql.HasFieldError(ctx, fc) {
 5564			ec.Errorf(ctx, "must not be null")
 5565		}
 5566		return graphql.Null
 5567	}
 5568	res := resTmp.(*time.Time)
 5569	fc.Result = res
 5570	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5571}
 5572
 5573func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5574	defer func() {
 5575		if r := recover(); r != nil {
 5576			ec.Error(ctx, ec.Recover(ctx, r))
 5577			ret = graphql.Null
 5578		}
 5579	}()
 5580	fc := &graphql.FieldContext{
 5581		Object:   "EditCommentOperation",
 5582		Field:    field,
 5583		Args:     nil,
 5584		IsMethod: true,
 5585	}
 5586
 5587	ctx = graphql.WithFieldContext(ctx, fc)
 5588	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5589		ctx = rctx // use context from middleware stack in children
 5590		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5591	})
 5592	if err != nil {
 5593		ec.Error(ctx, err)
 5594		return graphql.Null
 5595	}
 5596	if resTmp == nil {
 5597		if !graphql.HasFieldError(ctx, fc) {
 5598			ec.Errorf(ctx, "must not be null")
 5599		}
 5600		return graphql.Null
 5601	}
 5602	res := resTmp.(string)
 5603	fc.Result = res
 5604	return ec.marshalNString2string(ctx, field.Selections, res)
 5605}
 5606
 5607func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5608	defer func() {
 5609		if r := recover(); r != nil {
 5610			ec.Error(ctx, ec.Recover(ctx, r))
 5611			ret = graphql.Null
 5612		}
 5613	}()
 5614	fc := &graphql.FieldContext{
 5615		Object:   "EditCommentOperation",
 5616		Field:    field,
 5617		Args:     nil,
 5618		IsMethod: false,
 5619	}
 5620
 5621	ctx = graphql.WithFieldContext(ctx, fc)
 5622	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5623		ctx = rctx // use context from middleware stack in children
 5624		return obj.Message, nil
 5625	})
 5626	if err != nil {
 5627		ec.Error(ctx, err)
 5628		return graphql.Null
 5629	}
 5630	if resTmp == nil {
 5631		if !graphql.HasFieldError(ctx, fc) {
 5632			ec.Errorf(ctx, "must not be null")
 5633		}
 5634		return graphql.Null
 5635	}
 5636	res := resTmp.(string)
 5637	fc.Result = res
 5638	return ec.marshalNString2string(ctx, field.Selections, res)
 5639}
 5640
 5641func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5642	defer func() {
 5643		if r := recover(); r != nil {
 5644			ec.Error(ctx, ec.Recover(ctx, r))
 5645			ret = graphql.Null
 5646		}
 5647	}()
 5648	fc := &graphql.FieldContext{
 5649		Object:   "EditCommentOperation",
 5650		Field:    field,
 5651		Args:     nil,
 5652		IsMethod: false,
 5653	}
 5654
 5655	ctx = graphql.WithFieldContext(ctx, fc)
 5656	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5657		ctx = rctx // use context from middleware stack in children
 5658		return obj.Files, nil
 5659	})
 5660	if err != nil {
 5661		ec.Error(ctx, err)
 5662		return graphql.Null
 5663	}
 5664	if resTmp == nil {
 5665		if !graphql.HasFieldError(ctx, fc) {
 5666			ec.Errorf(ctx, "must not be null")
 5667		}
 5668		return graphql.Null
 5669	}
 5670	res := resTmp.([]repository.Hash)
 5671	fc.Result = res
 5672	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 5673}
 5674
 5675func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
 5676	defer func() {
 5677		if r := recover(); r != nil {
 5678			ec.Error(ctx, ec.Recover(ctx, r))
 5679			ret = graphql.Null
 5680		}
 5681	}()
 5682	fc := &graphql.FieldContext{
 5683		Object:   "EditCommentPayload",
 5684		Field:    field,
 5685		Args:     nil,
 5686		IsMethod: false,
 5687	}
 5688
 5689	ctx = graphql.WithFieldContext(ctx, fc)
 5690	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5691		ctx = rctx // use context from middleware stack in children
 5692		return obj.ClientMutationID, nil
 5693	})
 5694	if err != nil {
 5695		ec.Error(ctx, err)
 5696		return graphql.Null
 5697	}
 5698	if resTmp == nil {
 5699		return graphql.Null
 5700	}
 5701	res := resTmp.(*string)
 5702	fc.Result = res
 5703	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5704}
 5705
 5706func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
 5707	defer func() {
 5708		if r := recover(); r != nil {
 5709			ec.Error(ctx, ec.Recover(ctx, r))
 5710			ret = graphql.Null
 5711		}
 5712	}()
 5713	fc := &graphql.FieldContext{
 5714		Object:   "EditCommentPayload",
 5715		Field:    field,
 5716		Args:     nil,
 5717		IsMethod: false,
 5718	}
 5719
 5720	ctx = graphql.WithFieldContext(ctx, fc)
 5721	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5722		ctx = rctx // use context from middleware stack in children
 5723		return obj.Bug, nil
 5724	})
 5725	if err != nil {
 5726		ec.Error(ctx, err)
 5727		return graphql.Null
 5728	}
 5729	if resTmp == nil {
 5730		if !graphql.HasFieldError(ctx, fc) {
 5731			ec.Errorf(ctx, "must not be null")
 5732		}
 5733		return graphql.Null
 5734	}
 5735	res := resTmp.(models.BugWrapper)
 5736	fc.Result = res
 5737	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 5738}
 5739
 5740func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
 5741	defer func() {
 5742		if r := recover(); r != nil {
 5743			ec.Error(ctx, ec.Recover(ctx, r))
 5744			ret = graphql.Null
 5745		}
 5746	}()
 5747	fc := &graphql.FieldContext{
 5748		Object:   "EditCommentPayload",
 5749		Field:    field,
 5750		Args:     nil,
 5751		IsMethod: false,
 5752	}
 5753
 5754	ctx = graphql.WithFieldContext(ctx, fc)
 5755	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5756		ctx = rctx // use context from middleware stack in children
 5757		return obj.Operation, nil
 5758	})
 5759	if err != nil {
 5760		ec.Error(ctx, err)
 5761		return graphql.Null
 5762	}
 5763	if resTmp == nil {
 5764		if !graphql.HasFieldError(ctx, fc) {
 5765			ec.Errorf(ctx, "must not be null")
 5766		}
 5767		return graphql.Null
 5768	}
 5769	res := resTmp.(*bug.EditCommentOperation)
 5770	fc.Result = res
 5771	return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
 5772}
 5773
 5774func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5775	defer func() {
 5776		if r := recover(); r != nil {
 5777			ec.Error(ctx, ec.Recover(ctx, r))
 5778			ret = graphql.Null
 5779		}
 5780	}()
 5781	fc := &graphql.FieldContext{
 5782		Object:   "Identity",
 5783		Field:    field,
 5784		Args:     nil,
 5785		IsMethod: true,
 5786	}
 5787
 5788	ctx = graphql.WithFieldContext(ctx, fc)
 5789	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5790		ctx = rctx // use context from middleware stack in children
 5791		return ec.resolvers.Identity().ID(rctx, obj)
 5792	})
 5793	if err != nil {
 5794		ec.Error(ctx, err)
 5795		return graphql.Null
 5796	}
 5797	if resTmp == nil {
 5798		if !graphql.HasFieldError(ctx, fc) {
 5799			ec.Errorf(ctx, "must not be null")
 5800		}
 5801		return graphql.Null
 5802	}
 5803	res := resTmp.(string)
 5804	fc.Result = res
 5805	return ec.marshalNString2string(ctx, field.Selections, res)
 5806}
 5807
 5808func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5809	defer func() {
 5810		if r := recover(); r != nil {
 5811			ec.Error(ctx, ec.Recover(ctx, r))
 5812			ret = graphql.Null
 5813		}
 5814	}()
 5815	fc := &graphql.FieldContext{
 5816		Object:   "Identity",
 5817		Field:    field,
 5818		Args:     nil,
 5819		IsMethod: true,
 5820	}
 5821
 5822	ctx = graphql.WithFieldContext(ctx, fc)
 5823	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5824		ctx = rctx // use context from middleware stack in children
 5825		return ec.resolvers.Identity().HumanID(rctx, obj)
 5826	})
 5827	if err != nil {
 5828		ec.Error(ctx, err)
 5829		return graphql.Null
 5830	}
 5831	if resTmp == nil {
 5832		if !graphql.HasFieldError(ctx, fc) {
 5833			ec.Errorf(ctx, "must not be null")
 5834		}
 5835		return graphql.Null
 5836	}
 5837	res := resTmp.(string)
 5838	fc.Result = res
 5839	return ec.marshalNString2string(ctx, field.Selections, res)
 5840}
 5841
 5842func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5843	defer func() {
 5844		if r := recover(); r != nil {
 5845			ec.Error(ctx, ec.Recover(ctx, r))
 5846			ret = graphql.Null
 5847		}
 5848	}()
 5849	fc := &graphql.FieldContext{
 5850		Object:   "Identity",
 5851		Field:    field,
 5852		Args:     nil,
 5853		IsMethod: true,
 5854	}
 5855
 5856	ctx = graphql.WithFieldContext(ctx, fc)
 5857	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5858		ctx = rctx // use context from middleware stack in children
 5859		return obj.Name(), nil
 5860	})
 5861	if err != nil {
 5862		ec.Error(ctx, err)
 5863		return graphql.Null
 5864	}
 5865	if resTmp == nil {
 5866		return graphql.Null
 5867	}
 5868	res := resTmp.(string)
 5869	fc.Result = res
 5870	return ec.marshalOString2string(ctx, field.Selections, res)
 5871}
 5872
 5873func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5874	defer func() {
 5875		if r := recover(); r != nil {
 5876			ec.Error(ctx, ec.Recover(ctx, r))
 5877			ret = graphql.Null
 5878		}
 5879	}()
 5880	fc := &graphql.FieldContext{
 5881		Object:   "Identity",
 5882		Field:    field,
 5883		Args:     nil,
 5884		IsMethod: true,
 5885	}
 5886
 5887	ctx = graphql.WithFieldContext(ctx, fc)
 5888	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5889		ctx = rctx // use context from middleware stack in children
 5890		return obj.Email()
 5891	})
 5892	if err != nil {
 5893		ec.Error(ctx, err)
 5894		return graphql.Null
 5895	}
 5896	if resTmp == nil {
 5897		return graphql.Null
 5898	}
 5899	res := resTmp.(string)
 5900	fc.Result = res
 5901	return ec.marshalOString2string(ctx, field.Selections, res)
 5902}
 5903
 5904func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5905	defer func() {
 5906		if r := recover(); r != nil {
 5907			ec.Error(ctx, ec.Recover(ctx, r))
 5908			ret = graphql.Null
 5909		}
 5910	}()
 5911	fc := &graphql.FieldContext{
 5912		Object:   "Identity",
 5913		Field:    field,
 5914		Args:     nil,
 5915		IsMethod: true,
 5916	}
 5917
 5918	ctx = graphql.WithFieldContext(ctx, fc)
 5919	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5920		ctx = rctx // use context from middleware stack in children
 5921		return obj.Login()
 5922	})
 5923	if err != nil {
 5924		ec.Error(ctx, err)
 5925		return graphql.Null
 5926	}
 5927	if resTmp == nil {
 5928		return graphql.Null
 5929	}
 5930	res := resTmp.(string)
 5931	fc.Result = res
 5932	return ec.marshalOString2string(ctx, field.Selections, res)
 5933}
 5934
 5935func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5936	defer func() {
 5937		if r := recover(); r != nil {
 5938			ec.Error(ctx, ec.Recover(ctx, r))
 5939			ret = graphql.Null
 5940		}
 5941	}()
 5942	fc := &graphql.FieldContext{
 5943		Object:   "Identity",
 5944		Field:    field,
 5945		Args:     nil,
 5946		IsMethod: true,
 5947	}
 5948
 5949	ctx = graphql.WithFieldContext(ctx, fc)
 5950	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5951		ctx = rctx // use context from middleware stack in children
 5952		return obj.DisplayName(), nil
 5953	})
 5954	if err != nil {
 5955		ec.Error(ctx, err)
 5956		return graphql.Null
 5957	}
 5958	if resTmp == nil {
 5959		if !graphql.HasFieldError(ctx, fc) {
 5960			ec.Errorf(ctx, "must not be null")
 5961		}
 5962		return graphql.Null
 5963	}
 5964	res := resTmp.(string)
 5965	fc.Result = res
 5966	return ec.marshalNString2string(ctx, field.Selections, res)
 5967}
 5968
 5969func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5970	defer func() {
 5971		if r := recover(); r != nil {
 5972			ec.Error(ctx, ec.Recover(ctx, r))
 5973			ret = graphql.Null
 5974		}
 5975	}()
 5976	fc := &graphql.FieldContext{
 5977		Object:   "Identity",
 5978		Field:    field,
 5979		Args:     nil,
 5980		IsMethod: true,
 5981	}
 5982
 5983	ctx = graphql.WithFieldContext(ctx, fc)
 5984	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5985		ctx = rctx // use context from middleware stack in children
 5986		return obj.AvatarUrl()
 5987	})
 5988	if err != nil {
 5989		ec.Error(ctx, err)
 5990		return graphql.Null
 5991	}
 5992	if resTmp == nil {
 5993		return graphql.Null
 5994	}
 5995	res := resTmp.(string)
 5996	fc.Result = res
 5997	return ec.marshalOString2string(ctx, field.Selections, res)
 5998}
 5999
 6000func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 6001	defer func() {
 6002		if r := recover(); r != nil {
 6003			ec.Error(ctx, ec.Recover(ctx, r))
 6004			ret = graphql.Null
 6005		}
 6006	}()
 6007	fc := &graphql.FieldContext{
 6008		Object:   "Identity",
 6009		Field:    field,
 6010		Args:     nil,
 6011		IsMethod: true,
 6012	}
 6013
 6014	ctx = graphql.WithFieldContext(ctx, fc)
 6015	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6016		ctx = rctx // use context from middleware stack in children
 6017		return obj.IsProtected()
 6018	})
 6019	if err != nil {
 6020		ec.Error(ctx, err)
 6021		return graphql.Null
 6022	}
 6023	if resTmp == nil {
 6024		if !graphql.HasFieldError(ctx, fc) {
 6025			ec.Errorf(ctx, "must not be null")
 6026		}
 6027		return graphql.Null
 6028	}
 6029	res := resTmp.(bool)
 6030	fc.Result = res
 6031	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6032}
 6033
 6034func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6035	defer func() {
 6036		if r := recover(); r != nil {
 6037			ec.Error(ctx, ec.Recover(ctx, r))
 6038			ret = graphql.Null
 6039		}
 6040	}()
 6041	fc := &graphql.FieldContext{
 6042		Object:   "IdentityConnection",
 6043		Field:    field,
 6044		Args:     nil,
 6045		IsMethod: false,
 6046	}
 6047
 6048	ctx = graphql.WithFieldContext(ctx, fc)
 6049	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6050		ctx = rctx // use context from middleware stack in children
 6051		return obj.Edges, nil
 6052	})
 6053	if err != nil {
 6054		ec.Error(ctx, err)
 6055		return graphql.Null
 6056	}
 6057	if resTmp == nil {
 6058		if !graphql.HasFieldError(ctx, fc) {
 6059			ec.Errorf(ctx, "must not be null")
 6060		}
 6061		return graphql.Null
 6062	}
 6063	res := resTmp.([]*models.IdentityEdge)
 6064	fc.Result = res
 6065	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 6066}
 6067
 6068func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6069	defer func() {
 6070		if r := recover(); r != nil {
 6071			ec.Error(ctx, ec.Recover(ctx, r))
 6072			ret = graphql.Null
 6073		}
 6074	}()
 6075	fc := &graphql.FieldContext{
 6076		Object:   "IdentityConnection",
 6077		Field:    field,
 6078		Args:     nil,
 6079		IsMethod: false,
 6080	}
 6081
 6082	ctx = graphql.WithFieldContext(ctx, fc)
 6083	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6084		ctx = rctx // use context from middleware stack in children
 6085		return obj.Nodes, nil
 6086	})
 6087	if err != nil {
 6088		ec.Error(ctx, err)
 6089		return graphql.Null
 6090	}
 6091	if resTmp == nil {
 6092		if !graphql.HasFieldError(ctx, fc) {
 6093			ec.Errorf(ctx, "must not be null")
 6094		}
 6095		return graphql.Null
 6096	}
 6097	res := resTmp.([]models.IdentityWrapper)
 6098	fc.Result = res
 6099	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
 6100}
 6101
 6102func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6103	defer func() {
 6104		if r := recover(); r != nil {
 6105			ec.Error(ctx, ec.Recover(ctx, r))
 6106			ret = graphql.Null
 6107		}
 6108	}()
 6109	fc := &graphql.FieldContext{
 6110		Object:   "IdentityConnection",
 6111		Field:    field,
 6112		Args:     nil,
 6113		IsMethod: false,
 6114	}
 6115
 6116	ctx = graphql.WithFieldContext(ctx, fc)
 6117	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6118		ctx = rctx // use context from middleware stack in children
 6119		return obj.PageInfo, nil
 6120	})
 6121	if err != nil {
 6122		ec.Error(ctx, err)
 6123		return graphql.Null
 6124	}
 6125	if resTmp == nil {
 6126		if !graphql.HasFieldError(ctx, fc) {
 6127			ec.Errorf(ctx, "must not be null")
 6128		}
 6129		return graphql.Null
 6130	}
 6131	res := resTmp.(*models.PageInfo)
 6132	fc.Result = res
 6133	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6134}
 6135
 6136func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6137	defer func() {
 6138		if r := recover(); r != nil {
 6139			ec.Error(ctx, ec.Recover(ctx, r))
 6140			ret = graphql.Null
 6141		}
 6142	}()
 6143	fc := &graphql.FieldContext{
 6144		Object:   "IdentityConnection",
 6145		Field:    field,
 6146		Args:     nil,
 6147		IsMethod: false,
 6148	}
 6149
 6150	ctx = graphql.WithFieldContext(ctx, fc)
 6151	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6152		ctx = rctx // use context from middleware stack in children
 6153		return obj.TotalCount, nil
 6154	})
 6155	if err != nil {
 6156		ec.Error(ctx, err)
 6157		return graphql.Null
 6158	}
 6159	if resTmp == nil {
 6160		if !graphql.HasFieldError(ctx, fc) {
 6161			ec.Errorf(ctx, "must not be null")
 6162		}
 6163		return graphql.Null
 6164	}
 6165	res := resTmp.(int)
 6166	fc.Result = res
 6167	return ec.marshalNInt2int(ctx, field.Selections, res)
 6168}
 6169
 6170func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6171	defer func() {
 6172		if r := recover(); r != nil {
 6173			ec.Error(ctx, ec.Recover(ctx, r))
 6174			ret = graphql.Null
 6175		}
 6176	}()
 6177	fc := &graphql.FieldContext{
 6178		Object:   "IdentityEdge",
 6179		Field:    field,
 6180		Args:     nil,
 6181		IsMethod: false,
 6182	}
 6183
 6184	ctx = graphql.WithFieldContext(ctx, fc)
 6185	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6186		ctx = rctx // use context from middleware stack in children
 6187		return obj.Cursor, nil
 6188	})
 6189	if err != nil {
 6190		ec.Error(ctx, err)
 6191		return graphql.Null
 6192	}
 6193	if resTmp == nil {
 6194		if !graphql.HasFieldError(ctx, fc) {
 6195			ec.Errorf(ctx, "must not be null")
 6196		}
 6197		return graphql.Null
 6198	}
 6199	res := resTmp.(string)
 6200	fc.Result = res
 6201	return ec.marshalNString2string(ctx, field.Selections, res)
 6202}
 6203
 6204func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6205	defer func() {
 6206		if r := recover(); r != nil {
 6207			ec.Error(ctx, ec.Recover(ctx, r))
 6208			ret = graphql.Null
 6209		}
 6210	}()
 6211	fc := &graphql.FieldContext{
 6212		Object:   "IdentityEdge",
 6213		Field:    field,
 6214		Args:     nil,
 6215		IsMethod: false,
 6216	}
 6217
 6218	ctx = graphql.WithFieldContext(ctx, fc)
 6219	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6220		ctx = rctx // use context from middleware stack in children
 6221		return obj.Node, nil
 6222	})
 6223	if err != nil {
 6224		ec.Error(ctx, err)
 6225		return graphql.Null
 6226	}
 6227	if resTmp == nil {
 6228		if !graphql.HasFieldError(ctx, fc) {
 6229			ec.Errorf(ctx, "must not be null")
 6230		}
 6231		return graphql.Null
 6232	}
 6233	res := resTmp.(models.IdentityWrapper)
 6234	fc.Result = res
 6235	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6236}
 6237
 6238func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6239	defer func() {
 6240		if r := recover(); r != nil {
 6241			ec.Error(ctx, ec.Recover(ctx, r))
 6242			ret = graphql.Null
 6243		}
 6244	}()
 6245	fc := &graphql.FieldContext{
 6246		Object:   "Label",
 6247		Field:    field,
 6248		Args:     nil,
 6249		IsMethod: true,
 6250	}
 6251
 6252	ctx = graphql.WithFieldContext(ctx, fc)
 6253	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6254		ctx = rctx // use context from middleware stack in children
 6255		return ec.resolvers.Label().Name(rctx, obj)
 6256	})
 6257	if err != nil {
 6258		ec.Error(ctx, err)
 6259		return graphql.Null
 6260	}
 6261	if resTmp == nil {
 6262		if !graphql.HasFieldError(ctx, fc) {
 6263			ec.Errorf(ctx, "must not be null")
 6264		}
 6265		return graphql.Null
 6266	}
 6267	res := resTmp.(string)
 6268	fc.Result = res
 6269	return ec.marshalNString2string(ctx, field.Selections, res)
 6270}
 6271
 6272func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6273	defer func() {
 6274		if r := recover(); r != nil {
 6275			ec.Error(ctx, ec.Recover(ctx, r))
 6276			ret = graphql.Null
 6277		}
 6278	}()
 6279	fc := &graphql.FieldContext{
 6280		Object:   "Label",
 6281		Field:    field,
 6282		Args:     nil,
 6283		IsMethod: true,
 6284	}
 6285
 6286	ctx = graphql.WithFieldContext(ctx, fc)
 6287	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6288		ctx = rctx // use context from middleware stack in children
 6289		return ec.resolvers.Label().Color(rctx, obj)
 6290	})
 6291	if err != nil {
 6292		ec.Error(ctx, err)
 6293		return graphql.Null
 6294	}
 6295	if resTmp == nil {
 6296		if !graphql.HasFieldError(ctx, fc) {
 6297			ec.Errorf(ctx, "must not be null")
 6298		}
 6299		return graphql.Null
 6300	}
 6301	res := resTmp.(*color.RGBA)
 6302	fc.Result = res
 6303	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6304}
 6305
 6306func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6307	defer func() {
 6308		if r := recover(); r != nil {
 6309			ec.Error(ctx, ec.Recover(ctx, r))
 6310			ret = graphql.Null
 6311		}
 6312	}()
 6313	fc := &graphql.FieldContext{
 6314		Object:   "LabelChangeOperation",
 6315		Field:    field,
 6316		Args:     nil,
 6317		IsMethod: true,
 6318	}
 6319
 6320	ctx = graphql.WithFieldContext(ctx, fc)
 6321	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6322		ctx = rctx // use context from middleware stack in children
 6323		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6324	})
 6325	if err != nil {
 6326		ec.Error(ctx, err)
 6327		return graphql.Null
 6328	}
 6329	if resTmp == nil {
 6330		if !graphql.HasFieldError(ctx, fc) {
 6331			ec.Errorf(ctx, "must not be null")
 6332		}
 6333		return graphql.Null
 6334	}
 6335	res := resTmp.(string)
 6336	fc.Result = res
 6337	return ec.marshalNString2string(ctx, field.Selections, res)
 6338}
 6339
 6340func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6341	defer func() {
 6342		if r := recover(); r != nil {
 6343			ec.Error(ctx, ec.Recover(ctx, r))
 6344			ret = graphql.Null
 6345		}
 6346	}()
 6347	fc := &graphql.FieldContext{
 6348		Object:   "LabelChangeOperation",
 6349		Field:    field,
 6350		Args:     nil,
 6351		IsMethod: true,
 6352	}
 6353
 6354	ctx = graphql.WithFieldContext(ctx, fc)
 6355	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6356		ctx = rctx // use context from middleware stack in children
 6357		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
 6358	})
 6359	if err != nil {
 6360		ec.Error(ctx, err)
 6361		return graphql.Null
 6362	}
 6363	if resTmp == nil {
 6364		if !graphql.HasFieldError(ctx, fc) {
 6365			ec.Errorf(ctx, "must not be null")
 6366		}
 6367		return graphql.Null
 6368	}
 6369	res := resTmp.(models.IdentityWrapper)
 6370	fc.Result = res
 6371	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6372}
 6373
 6374func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6375	defer func() {
 6376		if r := recover(); r != nil {
 6377			ec.Error(ctx, ec.Recover(ctx, r))
 6378			ret = graphql.Null
 6379		}
 6380	}()
 6381	fc := &graphql.FieldContext{
 6382		Object:   "LabelChangeOperation",
 6383		Field:    field,
 6384		Args:     nil,
 6385		IsMethod: true,
 6386	}
 6387
 6388	ctx = graphql.WithFieldContext(ctx, fc)
 6389	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6390		ctx = rctx // use context from middleware stack in children
 6391		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6392	})
 6393	if err != nil {
 6394		ec.Error(ctx, err)
 6395		return graphql.Null
 6396	}
 6397	if resTmp == nil {
 6398		if !graphql.HasFieldError(ctx, fc) {
 6399			ec.Errorf(ctx, "must not be null")
 6400		}
 6401		return graphql.Null
 6402	}
 6403	res := resTmp.(*time.Time)
 6404	fc.Result = res
 6405	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6406}
 6407
 6408func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6409	defer func() {
 6410		if r := recover(); r != nil {
 6411			ec.Error(ctx, ec.Recover(ctx, r))
 6412			ret = graphql.Null
 6413		}
 6414	}()
 6415	fc := &graphql.FieldContext{
 6416		Object:   "LabelChangeOperation",
 6417		Field:    field,
 6418		Args:     nil,
 6419		IsMethod: false,
 6420	}
 6421
 6422	ctx = graphql.WithFieldContext(ctx, fc)
 6423	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6424		ctx = rctx // use context from middleware stack in children
 6425		return obj.Added, nil
 6426	})
 6427	if err != nil {
 6428		ec.Error(ctx, err)
 6429		return graphql.Null
 6430	}
 6431	if resTmp == nil {
 6432		if !graphql.HasFieldError(ctx, fc) {
 6433			ec.Errorf(ctx, "must not be null")
 6434		}
 6435		return graphql.Null
 6436	}
 6437	res := resTmp.([]bug.Label)
 6438	fc.Result = res
 6439	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6440}
 6441
 6442func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6443	defer func() {
 6444		if r := recover(); r != nil {
 6445			ec.Error(ctx, ec.Recover(ctx, r))
 6446			ret = graphql.Null
 6447		}
 6448	}()
 6449	fc := &graphql.FieldContext{
 6450		Object:   "LabelChangeOperation",
 6451		Field:    field,
 6452		Args:     nil,
 6453		IsMethod: false,
 6454	}
 6455
 6456	ctx = graphql.WithFieldContext(ctx, fc)
 6457	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6458		ctx = rctx // use context from middleware stack in children
 6459		return obj.Removed, nil
 6460	})
 6461	if err != nil {
 6462		ec.Error(ctx, err)
 6463		return graphql.Null
 6464	}
 6465	if resTmp == nil {
 6466		if !graphql.HasFieldError(ctx, fc) {
 6467			ec.Errorf(ctx, "must not be null")
 6468		}
 6469		return graphql.Null
 6470	}
 6471	res := resTmp.([]bug.Label)
 6472	fc.Result = res
 6473	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6474}
 6475
 6476func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6477	defer func() {
 6478		if r := recover(); r != nil {
 6479			ec.Error(ctx, ec.Recover(ctx, r))
 6480			ret = graphql.Null
 6481		}
 6482	}()
 6483	fc := &graphql.FieldContext{
 6484		Object:   "LabelChangeResult",
 6485		Field:    field,
 6486		Args:     nil,
 6487		IsMethod: false,
 6488	}
 6489
 6490	ctx = graphql.WithFieldContext(ctx, fc)
 6491	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6492		ctx = rctx // use context from middleware stack in children
 6493		return obj.Label, nil
 6494	})
 6495	if err != nil {
 6496		ec.Error(ctx, err)
 6497		return graphql.Null
 6498	}
 6499	if resTmp == nil {
 6500		if !graphql.HasFieldError(ctx, fc) {
 6501			ec.Errorf(ctx, "must not be null")
 6502		}
 6503		return graphql.Null
 6504	}
 6505	res := resTmp.(bug.Label)
 6506	fc.Result = res
 6507	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6508}
 6509
 6510func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6511	defer func() {
 6512		if r := recover(); r != nil {
 6513			ec.Error(ctx, ec.Recover(ctx, r))
 6514			ret = graphql.Null
 6515		}
 6516	}()
 6517	fc := &graphql.FieldContext{
 6518		Object:   "LabelChangeResult",
 6519		Field:    field,
 6520		Args:     nil,
 6521		IsMethod: true,
 6522	}
 6523
 6524	ctx = graphql.WithFieldContext(ctx, fc)
 6525	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6526		ctx = rctx // use context from middleware stack in children
 6527		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6528	})
 6529	if err != nil {
 6530		ec.Error(ctx, err)
 6531		return graphql.Null
 6532	}
 6533	if resTmp == nil {
 6534		if !graphql.HasFieldError(ctx, fc) {
 6535			ec.Errorf(ctx, "must not be null")
 6536		}
 6537		return graphql.Null
 6538	}
 6539	res := resTmp.(models.LabelChangeStatus)
 6540	fc.Result = res
 6541	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6542}
 6543
 6544func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6545	defer func() {
 6546		if r := recover(); r != nil {
 6547			ec.Error(ctx, ec.Recover(ctx, r))
 6548			ret = graphql.Null
 6549		}
 6550	}()
 6551	fc := &graphql.FieldContext{
 6552		Object:   "LabelChangeTimelineItem",
 6553		Field:    field,
 6554		Args:     nil,
 6555		IsMethod: true,
 6556	}
 6557
 6558	ctx = graphql.WithFieldContext(ctx, fc)
 6559	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6560		ctx = rctx // use context from middleware stack in children
 6561		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6562	})
 6563	if err != nil {
 6564		ec.Error(ctx, err)
 6565		return graphql.Null
 6566	}
 6567	if resTmp == nil {
 6568		if !graphql.HasFieldError(ctx, fc) {
 6569			ec.Errorf(ctx, "must not be null")
 6570		}
 6571		return graphql.Null
 6572	}
 6573	res := resTmp.(string)
 6574	fc.Result = res
 6575	return ec.marshalNString2string(ctx, field.Selections, res)
 6576}
 6577
 6578func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6579	defer func() {
 6580		if r := recover(); r != nil {
 6581			ec.Error(ctx, ec.Recover(ctx, r))
 6582			ret = graphql.Null
 6583		}
 6584	}()
 6585	fc := &graphql.FieldContext{
 6586		Object:   "LabelChangeTimelineItem",
 6587		Field:    field,
 6588		Args:     nil,
 6589		IsMethod: true,
 6590	}
 6591
 6592	ctx = graphql.WithFieldContext(ctx, fc)
 6593	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6594		ctx = rctx // use context from middleware stack in children
 6595		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
 6596	})
 6597	if err != nil {
 6598		ec.Error(ctx, err)
 6599		return graphql.Null
 6600	}
 6601	if resTmp == nil {
 6602		if !graphql.HasFieldError(ctx, fc) {
 6603			ec.Errorf(ctx, "must not be null")
 6604		}
 6605		return graphql.Null
 6606	}
 6607	res := resTmp.(models.IdentityWrapper)
 6608	fc.Result = res
 6609	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6610}
 6611
 6612func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6613	defer func() {
 6614		if r := recover(); r != nil {
 6615			ec.Error(ctx, ec.Recover(ctx, r))
 6616			ret = graphql.Null
 6617		}
 6618	}()
 6619	fc := &graphql.FieldContext{
 6620		Object:   "LabelChangeTimelineItem",
 6621		Field:    field,
 6622		Args:     nil,
 6623		IsMethod: true,
 6624	}
 6625
 6626	ctx = graphql.WithFieldContext(ctx, fc)
 6627	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6628		ctx = rctx // use context from middleware stack in children
 6629		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6630	})
 6631	if err != nil {
 6632		ec.Error(ctx, err)
 6633		return graphql.Null
 6634	}
 6635	if resTmp == nil {
 6636		if !graphql.HasFieldError(ctx, fc) {
 6637			ec.Errorf(ctx, "must not be null")
 6638		}
 6639		return graphql.Null
 6640	}
 6641	res := resTmp.(*time.Time)
 6642	fc.Result = res
 6643	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6644}
 6645
 6646func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6647	defer func() {
 6648		if r := recover(); r != nil {
 6649			ec.Error(ctx, ec.Recover(ctx, r))
 6650			ret = graphql.Null
 6651		}
 6652	}()
 6653	fc := &graphql.FieldContext{
 6654		Object:   "LabelChangeTimelineItem",
 6655		Field:    field,
 6656		Args:     nil,
 6657		IsMethod: false,
 6658	}
 6659
 6660	ctx = graphql.WithFieldContext(ctx, fc)
 6661	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6662		ctx = rctx // use context from middleware stack in children
 6663		return obj.Added, nil
 6664	})
 6665	if err != nil {
 6666		ec.Error(ctx, err)
 6667		return graphql.Null
 6668	}
 6669	if resTmp == nil {
 6670		if !graphql.HasFieldError(ctx, fc) {
 6671			ec.Errorf(ctx, "must not be null")
 6672		}
 6673		return graphql.Null
 6674	}
 6675	res := resTmp.([]bug.Label)
 6676	fc.Result = res
 6677	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6678}
 6679
 6680func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6681	defer func() {
 6682		if r := recover(); r != nil {
 6683			ec.Error(ctx, ec.Recover(ctx, r))
 6684			ret = graphql.Null
 6685		}
 6686	}()
 6687	fc := &graphql.FieldContext{
 6688		Object:   "LabelChangeTimelineItem",
 6689		Field:    field,
 6690		Args:     nil,
 6691		IsMethod: false,
 6692	}
 6693
 6694	ctx = graphql.WithFieldContext(ctx, fc)
 6695	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6696		ctx = rctx // use context from middleware stack in children
 6697		return obj.Removed, nil
 6698	})
 6699	if err != nil {
 6700		ec.Error(ctx, err)
 6701		return graphql.Null
 6702	}
 6703	if resTmp == nil {
 6704		if !graphql.HasFieldError(ctx, fc) {
 6705			ec.Errorf(ctx, "must not be null")
 6706		}
 6707		return graphql.Null
 6708	}
 6709	res := resTmp.([]bug.Label)
 6710	fc.Result = res
 6711	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6712}
 6713
 6714func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6715	defer func() {
 6716		if r := recover(); r != nil {
 6717			ec.Error(ctx, ec.Recover(ctx, r))
 6718			ret = graphql.Null
 6719		}
 6720	}()
 6721	fc := &graphql.FieldContext{
 6722		Object:   "LabelConnection",
 6723		Field:    field,
 6724		Args:     nil,
 6725		IsMethod: false,
 6726	}
 6727
 6728	ctx = graphql.WithFieldContext(ctx, fc)
 6729	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6730		ctx = rctx // use context from middleware stack in children
 6731		return obj.Edges, nil
 6732	})
 6733	if err != nil {
 6734		ec.Error(ctx, err)
 6735		return graphql.Null
 6736	}
 6737	if resTmp == nil {
 6738		if !graphql.HasFieldError(ctx, fc) {
 6739			ec.Errorf(ctx, "must not be null")
 6740		}
 6741		return graphql.Null
 6742	}
 6743	res := resTmp.([]*models.LabelEdge)
 6744	fc.Result = res
 6745	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 6746}
 6747
 6748func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6749	defer func() {
 6750		if r := recover(); r != nil {
 6751			ec.Error(ctx, ec.Recover(ctx, r))
 6752			ret = graphql.Null
 6753		}
 6754	}()
 6755	fc := &graphql.FieldContext{
 6756		Object:   "LabelConnection",
 6757		Field:    field,
 6758		Args:     nil,
 6759		IsMethod: false,
 6760	}
 6761
 6762	ctx = graphql.WithFieldContext(ctx, fc)
 6763	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6764		ctx = rctx // use context from middleware stack in children
 6765		return obj.Nodes, nil
 6766	})
 6767	if err != nil {
 6768		ec.Error(ctx, err)
 6769		return graphql.Null
 6770	}
 6771	if resTmp == nil {
 6772		if !graphql.HasFieldError(ctx, fc) {
 6773			ec.Errorf(ctx, "must not be null")
 6774		}
 6775		return graphql.Null
 6776	}
 6777	res := resTmp.([]bug.Label)
 6778	fc.Result = res
 6779	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6780}
 6781
 6782func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6783	defer func() {
 6784		if r := recover(); r != nil {
 6785			ec.Error(ctx, ec.Recover(ctx, r))
 6786			ret = graphql.Null
 6787		}
 6788	}()
 6789	fc := &graphql.FieldContext{
 6790		Object:   "LabelConnection",
 6791		Field:    field,
 6792		Args:     nil,
 6793		IsMethod: false,
 6794	}
 6795
 6796	ctx = graphql.WithFieldContext(ctx, fc)
 6797	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6798		ctx = rctx // use context from middleware stack in children
 6799		return obj.PageInfo, nil
 6800	})
 6801	if err != nil {
 6802		ec.Error(ctx, err)
 6803		return graphql.Null
 6804	}
 6805	if resTmp == nil {
 6806		if !graphql.HasFieldError(ctx, fc) {
 6807			ec.Errorf(ctx, "must not be null")
 6808		}
 6809		return graphql.Null
 6810	}
 6811	res := resTmp.(*models.PageInfo)
 6812	fc.Result = res
 6813	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6814}
 6815
 6816func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6817	defer func() {
 6818		if r := recover(); r != nil {
 6819			ec.Error(ctx, ec.Recover(ctx, r))
 6820			ret = graphql.Null
 6821		}
 6822	}()
 6823	fc := &graphql.FieldContext{
 6824		Object:   "LabelConnection",
 6825		Field:    field,
 6826		Args:     nil,
 6827		IsMethod: false,
 6828	}
 6829
 6830	ctx = graphql.WithFieldContext(ctx, fc)
 6831	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6832		ctx = rctx // use context from middleware stack in children
 6833		return obj.TotalCount, nil
 6834	})
 6835	if err != nil {
 6836		ec.Error(ctx, err)
 6837		return graphql.Null
 6838	}
 6839	if resTmp == nil {
 6840		if !graphql.HasFieldError(ctx, fc) {
 6841			ec.Errorf(ctx, "must not be null")
 6842		}
 6843		return graphql.Null
 6844	}
 6845	res := resTmp.(int)
 6846	fc.Result = res
 6847	return ec.marshalNInt2int(ctx, field.Selections, res)
 6848}
 6849
 6850func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6851	defer func() {
 6852		if r := recover(); r != nil {
 6853			ec.Error(ctx, ec.Recover(ctx, r))
 6854			ret = graphql.Null
 6855		}
 6856	}()
 6857	fc := &graphql.FieldContext{
 6858		Object:   "LabelEdge",
 6859		Field:    field,
 6860		Args:     nil,
 6861		IsMethod: false,
 6862	}
 6863
 6864	ctx = graphql.WithFieldContext(ctx, fc)
 6865	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6866		ctx = rctx // use context from middleware stack in children
 6867		return obj.Cursor, nil
 6868	})
 6869	if err != nil {
 6870		ec.Error(ctx, err)
 6871		return graphql.Null
 6872	}
 6873	if resTmp == nil {
 6874		if !graphql.HasFieldError(ctx, fc) {
 6875			ec.Errorf(ctx, "must not be null")
 6876		}
 6877		return graphql.Null
 6878	}
 6879	res := resTmp.(string)
 6880	fc.Result = res
 6881	return ec.marshalNString2string(ctx, field.Selections, res)
 6882}
 6883
 6884func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6885	defer func() {
 6886		if r := recover(); r != nil {
 6887			ec.Error(ctx, ec.Recover(ctx, r))
 6888			ret = graphql.Null
 6889		}
 6890	}()
 6891	fc := &graphql.FieldContext{
 6892		Object:   "LabelEdge",
 6893		Field:    field,
 6894		Args:     nil,
 6895		IsMethod: false,
 6896	}
 6897
 6898	ctx = graphql.WithFieldContext(ctx, fc)
 6899	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6900		ctx = rctx // use context from middleware stack in children
 6901		return obj.Node, nil
 6902	})
 6903	if err != nil {
 6904		ec.Error(ctx, err)
 6905		return graphql.Null
 6906	}
 6907	if resTmp == nil {
 6908		if !graphql.HasFieldError(ctx, fc) {
 6909			ec.Errorf(ctx, "must not be null")
 6910		}
 6911		return graphql.Null
 6912	}
 6913	res := resTmp.(bug.Label)
 6914	fc.Result = res
 6915	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6916}
 6917
 6918func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6919	defer func() {
 6920		if r := recover(); r != nil {
 6921			ec.Error(ctx, ec.Recover(ctx, r))
 6922			ret = graphql.Null
 6923		}
 6924	}()
 6925	fc := &graphql.FieldContext{
 6926		Object:   "Mutation",
 6927		Field:    field,
 6928		Args:     nil,
 6929		IsMethod: true,
 6930	}
 6931
 6932	ctx = graphql.WithFieldContext(ctx, fc)
 6933	rawArgs := field.ArgumentMap(ec.Variables)
 6934	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6935	if err != nil {
 6936		ec.Error(ctx, err)
 6937		return graphql.Null
 6938	}
 6939	fc.Args = args
 6940	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6941		ctx = rctx // use context from middleware stack in children
 6942		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 6943	})
 6944	if err != nil {
 6945		ec.Error(ctx, err)
 6946		return graphql.Null
 6947	}
 6948	if resTmp == nil {
 6949		if !graphql.HasFieldError(ctx, fc) {
 6950			ec.Errorf(ctx, "must not be null")
 6951		}
 6952		return graphql.Null
 6953	}
 6954	res := resTmp.(*models.NewBugPayload)
 6955	fc.Result = res
 6956	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 6957}
 6958
 6959func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6960	defer func() {
 6961		if r := recover(); r != nil {
 6962			ec.Error(ctx, ec.Recover(ctx, r))
 6963			ret = graphql.Null
 6964		}
 6965	}()
 6966	fc := &graphql.FieldContext{
 6967		Object:   "Mutation",
 6968		Field:    field,
 6969		Args:     nil,
 6970		IsMethod: true,
 6971	}
 6972
 6973	ctx = graphql.WithFieldContext(ctx, fc)
 6974	rawArgs := field.ArgumentMap(ec.Variables)
 6975	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 6976	if err != nil {
 6977		ec.Error(ctx, err)
 6978		return graphql.Null
 6979	}
 6980	fc.Args = args
 6981	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6982		ctx = rctx // use context from middleware stack in children
 6983		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 6984	})
 6985	if err != nil {
 6986		ec.Error(ctx, err)
 6987		return graphql.Null
 6988	}
 6989	if resTmp == nil {
 6990		if !graphql.HasFieldError(ctx, fc) {
 6991			ec.Errorf(ctx, "must not be null")
 6992		}
 6993		return graphql.Null
 6994	}
 6995	res := resTmp.(*models.AddCommentPayload)
 6996	fc.Result = res
 6997	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 6998}
 6999
 7000func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7001	defer func() {
 7002		if r := recover(); r != nil {
 7003			ec.Error(ctx, ec.Recover(ctx, r))
 7004			ret = graphql.Null
 7005		}
 7006	}()
 7007	fc := &graphql.FieldContext{
 7008		Object:   "Mutation",
 7009		Field:    field,
 7010		Args:     nil,
 7011		IsMethod: true,
 7012	}
 7013
 7014	ctx = graphql.WithFieldContext(ctx, fc)
 7015	rawArgs := field.ArgumentMap(ec.Variables)
 7016	args, err := ec.field_Mutation_editComment_args(ctx, rawArgs)
 7017	if err != nil {
 7018		ec.Error(ctx, err)
 7019		return graphql.Null
 7020	}
 7021	fc.Args = args
 7022	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7023		ctx = rctx // use context from middleware stack in children
 7024		return ec.resolvers.Mutation().EditComment(rctx, args["input"].(models.EditCommentInput))
 7025	})
 7026	if err != nil {
 7027		ec.Error(ctx, err)
 7028		return graphql.Null
 7029	}
 7030	if resTmp == nil {
 7031		if !graphql.HasFieldError(ctx, fc) {
 7032			ec.Errorf(ctx, "must not be null")
 7033		}
 7034		return graphql.Null
 7035	}
 7036	res := resTmp.(*models.EditCommentPayload)
 7037	fc.Result = res
 7038	return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
 7039}
 7040
 7041func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7042	defer func() {
 7043		if r := recover(); r != nil {
 7044			ec.Error(ctx, ec.Recover(ctx, r))
 7045			ret = graphql.Null
 7046		}
 7047	}()
 7048	fc := &graphql.FieldContext{
 7049		Object:   "Mutation",
 7050		Field:    field,
 7051		Args:     nil,
 7052		IsMethod: true,
 7053	}
 7054
 7055	ctx = graphql.WithFieldContext(ctx, fc)
 7056	rawArgs := field.ArgumentMap(ec.Variables)
 7057	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 7058	if err != nil {
 7059		ec.Error(ctx, err)
 7060		return graphql.Null
 7061	}
 7062	fc.Args = args
 7063	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7064		ctx = rctx // use context from middleware stack in children
 7065		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 7066	})
 7067	if err != nil {
 7068		ec.Error(ctx, err)
 7069		return graphql.Null
 7070	}
 7071	if resTmp == nil {
 7072		if !graphql.HasFieldError(ctx, fc) {
 7073			ec.Errorf(ctx, "must not be null")
 7074		}
 7075		return graphql.Null
 7076	}
 7077	res := resTmp.(*models.ChangeLabelPayload)
 7078	fc.Result = res
 7079	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 7080}
 7081
 7082func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7083	defer func() {
 7084		if r := recover(); r != nil {
 7085			ec.Error(ctx, ec.Recover(ctx, r))
 7086			ret = graphql.Null
 7087		}
 7088	}()
 7089	fc := &graphql.FieldContext{
 7090		Object:   "Mutation",
 7091		Field:    field,
 7092		Args:     nil,
 7093		IsMethod: true,
 7094	}
 7095
 7096	ctx = graphql.WithFieldContext(ctx, fc)
 7097	rawArgs := field.ArgumentMap(ec.Variables)
 7098	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 7099	if err != nil {
 7100		ec.Error(ctx, err)
 7101		return graphql.Null
 7102	}
 7103	fc.Args = args
 7104	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7105		ctx = rctx // use context from middleware stack in children
 7106		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 7107	})
 7108	if err != nil {
 7109		ec.Error(ctx, err)
 7110		return graphql.Null
 7111	}
 7112	if resTmp == nil {
 7113		if !graphql.HasFieldError(ctx, fc) {
 7114			ec.Errorf(ctx, "must not be null")
 7115		}
 7116		return graphql.Null
 7117	}
 7118	res := resTmp.(*models.OpenBugPayload)
 7119	fc.Result = res
 7120	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 7121}
 7122
 7123func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7124	defer func() {
 7125		if r := recover(); r != nil {
 7126			ec.Error(ctx, ec.Recover(ctx, r))
 7127			ret = graphql.Null
 7128		}
 7129	}()
 7130	fc := &graphql.FieldContext{
 7131		Object:   "Mutation",
 7132		Field:    field,
 7133		Args:     nil,
 7134		IsMethod: true,
 7135	}
 7136
 7137	ctx = graphql.WithFieldContext(ctx, fc)
 7138	rawArgs := field.ArgumentMap(ec.Variables)
 7139	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 7140	if err != nil {
 7141		ec.Error(ctx, err)
 7142		return graphql.Null
 7143	}
 7144	fc.Args = args
 7145	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7146		ctx = rctx // use context from middleware stack in children
 7147		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 7148	})
 7149	if err != nil {
 7150		ec.Error(ctx, err)
 7151		return graphql.Null
 7152	}
 7153	if resTmp == nil {
 7154		if !graphql.HasFieldError(ctx, fc) {
 7155			ec.Errorf(ctx, "must not be null")
 7156		}
 7157		return graphql.Null
 7158	}
 7159	res := resTmp.(*models.CloseBugPayload)
 7160	fc.Result = res
 7161	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 7162}
 7163
 7164func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7165	defer func() {
 7166		if r := recover(); r != nil {
 7167			ec.Error(ctx, ec.Recover(ctx, r))
 7168			ret = graphql.Null
 7169		}
 7170	}()
 7171	fc := &graphql.FieldContext{
 7172		Object:   "Mutation",
 7173		Field:    field,
 7174		Args:     nil,
 7175		IsMethod: true,
 7176	}
 7177
 7178	ctx = graphql.WithFieldContext(ctx, fc)
 7179	rawArgs := field.ArgumentMap(ec.Variables)
 7180	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 7181	if err != nil {
 7182		ec.Error(ctx, err)
 7183		return graphql.Null
 7184	}
 7185	fc.Args = args
 7186	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7187		ctx = rctx // use context from middleware stack in children
 7188		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 7189	})
 7190	if err != nil {
 7191		ec.Error(ctx, err)
 7192		return graphql.Null
 7193	}
 7194	if resTmp == nil {
 7195		if !graphql.HasFieldError(ctx, fc) {
 7196			ec.Errorf(ctx, "must not be null")
 7197		}
 7198		return graphql.Null
 7199	}
 7200	res := resTmp.(*models.SetTitlePayload)
 7201	fc.Result = res
 7202	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 7203}
 7204
 7205func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7206	defer func() {
 7207		if r := recover(); r != nil {
 7208			ec.Error(ctx, ec.Recover(ctx, r))
 7209			ret = graphql.Null
 7210		}
 7211	}()
 7212	fc := &graphql.FieldContext{
 7213		Object:   "NewBugPayload",
 7214		Field:    field,
 7215		Args:     nil,
 7216		IsMethod: false,
 7217	}
 7218
 7219	ctx = graphql.WithFieldContext(ctx, fc)
 7220	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7221		ctx = rctx // use context from middleware stack in children
 7222		return obj.ClientMutationID, nil
 7223	})
 7224	if err != nil {
 7225		ec.Error(ctx, err)
 7226		return graphql.Null
 7227	}
 7228	if resTmp == nil {
 7229		return graphql.Null
 7230	}
 7231	res := resTmp.(*string)
 7232	fc.Result = res
 7233	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7234}
 7235
 7236func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7237	defer func() {
 7238		if r := recover(); r != nil {
 7239			ec.Error(ctx, ec.Recover(ctx, r))
 7240			ret = graphql.Null
 7241		}
 7242	}()
 7243	fc := &graphql.FieldContext{
 7244		Object:   "NewBugPayload",
 7245		Field:    field,
 7246		Args:     nil,
 7247		IsMethod: false,
 7248	}
 7249
 7250	ctx = graphql.WithFieldContext(ctx, fc)
 7251	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7252		ctx = rctx // use context from middleware stack in children
 7253		return obj.Bug, nil
 7254	})
 7255	if err != nil {
 7256		ec.Error(ctx, err)
 7257		return graphql.Null
 7258	}
 7259	if resTmp == nil {
 7260		if !graphql.HasFieldError(ctx, fc) {
 7261			ec.Errorf(ctx, "must not be null")
 7262		}
 7263		return graphql.Null
 7264	}
 7265	res := resTmp.(models.BugWrapper)
 7266	fc.Result = res
 7267	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7268}
 7269
 7270func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7271	defer func() {
 7272		if r := recover(); r != nil {
 7273			ec.Error(ctx, ec.Recover(ctx, r))
 7274			ret = graphql.Null
 7275		}
 7276	}()
 7277	fc := &graphql.FieldContext{
 7278		Object:   "NewBugPayload",
 7279		Field:    field,
 7280		Args:     nil,
 7281		IsMethod: false,
 7282	}
 7283
 7284	ctx = graphql.WithFieldContext(ctx, fc)
 7285	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7286		ctx = rctx // use context from middleware stack in children
 7287		return obj.Operation, nil
 7288	})
 7289	if err != nil {
 7290		ec.Error(ctx, err)
 7291		return graphql.Null
 7292	}
 7293	if resTmp == nil {
 7294		if !graphql.HasFieldError(ctx, fc) {
 7295			ec.Errorf(ctx, "must not be null")
 7296		}
 7297		return graphql.Null
 7298	}
 7299	res := resTmp.(*bug.CreateOperation)
 7300	fc.Result = res
 7301	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7302}
 7303
 7304func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7305	defer func() {
 7306		if r := recover(); r != nil {
 7307			ec.Error(ctx, ec.Recover(ctx, r))
 7308			ret = graphql.Null
 7309		}
 7310	}()
 7311	fc := &graphql.FieldContext{
 7312		Object:   "OpenBugPayload",
 7313		Field:    field,
 7314		Args:     nil,
 7315		IsMethod: false,
 7316	}
 7317
 7318	ctx = graphql.WithFieldContext(ctx, fc)
 7319	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7320		ctx = rctx // use context from middleware stack in children
 7321		return obj.ClientMutationID, nil
 7322	})
 7323	if err != nil {
 7324		ec.Error(ctx, err)
 7325		return graphql.Null
 7326	}
 7327	if resTmp == nil {
 7328		return graphql.Null
 7329	}
 7330	res := resTmp.(*string)
 7331	fc.Result = res
 7332	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7333}
 7334
 7335func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7336	defer func() {
 7337		if r := recover(); r != nil {
 7338			ec.Error(ctx, ec.Recover(ctx, r))
 7339			ret = graphql.Null
 7340		}
 7341	}()
 7342	fc := &graphql.FieldContext{
 7343		Object:   "OpenBugPayload",
 7344		Field:    field,
 7345		Args:     nil,
 7346		IsMethod: false,
 7347	}
 7348
 7349	ctx = graphql.WithFieldContext(ctx, fc)
 7350	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7351		ctx = rctx // use context from middleware stack in children
 7352		return obj.Bug, nil
 7353	})
 7354	if err != nil {
 7355		ec.Error(ctx, err)
 7356		return graphql.Null
 7357	}
 7358	if resTmp == nil {
 7359		if !graphql.HasFieldError(ctx, fc) {
 7360			ec.Errorf(ctx, "must not be null")
 7361		}
 7362		return graphql.Null
 7363	}
 7364	res := resTmp.(models.BugWrapper)
 7365	fc.Result = res
 7366	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7367}
 7368
 7369func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7370	defer func() {
 7371		if r := recover(); r != nil {
 7372			ec.Error(ctx, ec.Recover(ctx, r))
 7373			ret = graphql.Null
 7374		}
 7375	}()
 7376	fc := &graphql.FieldContext{
 7377		Object:   "OpenBugPayload",
 7378		Field:    field,
 7379		Args:     nil,
 7380		IsMethod: false,
 7381	}
 7382
 7383	ctx = graphql.WithFieldContext(ctx, fc)
 7384	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7385		ctx = rctx // use context from middleware stack in children
 7386		return obj.Operation, nil
 7387	})
 7388	if err != nil {
 7389		ec.Error(ctx, err)
 7390		return graphql.Null
 7391	}
 7392	if resTmp == nil {
 7393		if !graphql.HasFieldError(ctx, fc) {
 7394			ec.Errorf(ctx, "must not be null")
 7395		}
 7396		return graphql.Null
 7397	}
 7398	res := resTmp.(*bug.SetStatusOperation)
 7399	fc.Result = res
 7400	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7401}
 7402
 7403func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7404	defer func() {
 7405		if r := recover(); r != nil {
 7406			ec.Error(ctx, ec.Recover(ctx, r))
 7407			ret = graphql.Null
 7408		}
 7409	}()
 7410	fc := &graphql.FieldContext{
 7411		Object:   "OperationConnection",
 7412		Field:    field,
 7413		Args:     nil,
 7414		IsMethod: false,
 7415	}
 7416
 7417	ctx = graphql.WithFieldContext(ctx, fc)
 7418	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7419		ctx = rctx // use context from middleware stack in children
 7420		return obj.Edges, nil
 7421	})
 7422	if err != nil {
 7423		ec.Error(ctx, err)
 7424		return graphql.Null
 7425	}
 7426	if resTmp == nil {
 7427		if !graphql.HasFieldError(ctx, fc) {
 7428			ec.Errorf(ctx, "must not be null")
 7429		}
 7430		return graphql.Null
 7431	}
 7432	res := resTmp.([]*models.OperationEdge)
 7433	fc.Result = res
 7434	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7435}
 7436
 7437func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7438	defer func() {
 7439		if r := recover(); r != nil {
 7440			ec.Error(ctx, ec.Recover(ctx, r))
 7441			ret = graphql.Null
 7442		}
 7443	}()
 7444	fc := &graphql.FieldContext{
 7445		Object:   "OperationConnection",
 7446		Field:    field,
 7447		Args:     nil,
 7448		IsMethod: false,
 7449	}
 7450
 7451	ctx = graphql.WithFieldContext(ctx, fc)
 7452	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7453		ctx = rctx // use context from middleware stack in children
 7454		return obj.Nodes, nil
 7455	})
 7456	if err != nil {
 7457		ec.Error(ctx, err)
 7458		return graphql.Null
 7459	}
 7460	if resTmp == nil {
 7461		if !graphql.HasFieldError(ctx, fc) {
 7462			ec.Errorf(ctx, "must not be null")
 7463		}
 7464		return graphql.Null
 7465	}
 7466	res := resTmp.([]bug.Operation)
 7467	fc.Result = res
 7468	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7469}
 7470
 7471func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7472	defer func() {
 7473		if r := recover(); r != nil {
 7474			ec.Error(ctx, ec.Recover(ctx, r))
 7475			ret = graphql.Null
 7476		}
 7477	}()
 7478	fc := &graphql.FieldContext{
 7479		Object:   "OperationConnection",
 7480		Field:    field,
 7481		Args:     nil,
 7482		IsMethod: false,
 7483	}
 7484
 7485	ctx = graphql.WithFieldContext(ctx, fc)
 7486	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7487		ctx = rctx // use context from middleware stack in children
 7488		return obj.PageInfo, nil
 7489	})
 7490	if err != nil {
 7491		ec.Error(ctx, err)
 7492		return graphql.Null
 7493	}
 7494	if resTmp == nil {
 7495		if !graphql.HasFieldError(ctx, fc) {
 7496			ec.Errorf(ctx, "must not be null")
 7497		}
 7498		return graphql.Null
 7499	}
 7500	res := resTmp.(*models.PageInfo)
 7501	fc.Result = res
 7502	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7503}
 7504
 7505func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7506	defer func() {
 7507		if r := recover(); r != nil {
 7508			ec.Error(ctx, ec.Recover(ctx, r))
 7509			ret = graphql.Null
 7510		}
 7511	}()
 7512	fc := &graphql.FieldContext{
 7513		Object:   "OperationConnection",
 7514		Field:    field,
 7515		Args:     nil,
 7516		IsMethod: false,
 7517	}
 7518
 7519	ctx = graphql.WithFieldContext(ctx, fc)
 7520	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7521		ctx = rctx // use context from middleware stack in children
 7522		return obj.TotalCount, nil
 7523	})
 7524	if err != nil {
 7525		ec.Error(ctx, err)
 7526		return graphql.Null
 7527	}
 7528	if resTmp == nil {
 7529		if !graphql.HasFieldError(ctx, fc) {
 7530			ec.Errorf(ctx, "must not be null")
 7531		}
 7532		return graphql.Null
 7533	}
 7534	res := resTmp.(int)
 7535	fc.Result = res
 7536	return ec.marshalNInt2int(ctx, field.Selections, res)
 7537}
 7538
 7539func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7540	defer func() {
 7541		if r := recover(); r != nil {
 7542			ec.Error(ctx, ec.Recover(ctx, r))
 7543			ret = graphql.Null
 7544		}
 7545	}()
 7546	fc := &graphql.FieldContext{
 7547		Object:   "OperationEdge",
 7548		Field:    field,
 7549		Args:     nil,
 7550		IsMethod: false,
 7551	}
 7552
 7553	ctx = graphql.WithFieldContext(ctx, fc)
 7554	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7555		ctx = rctx // use context from middleware stack in children
 7556		return obj.Cursor, nil
 7557	})
 7558	if err != nil {
 7559		ec.Error(ctx, err)
 7560		return graphql.Null
 7561	}
 7562	if resTmp == nil {
 7563		if !graphql.HasFieldError(ctx, fc) {
 7564			ec.Errorf(ctx, "must not be null")
 7565		}
 7566		return graphql.Null
 7567	}
 7568	res := resTmp.(string)
 7569	fc.Result = res
 7570	return ec.marshalNString2string(ctx, field.Selections, res)
 7571}
 7572
 7573func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7574	defer func() {
 7575		if r := recover(); r != nil {
 7576			ec.Error(ctx, ec.Recover(ctx, r))
 7577			ret = graphql.Null
 7578		}
 7579	}()
 7580	fc := &graphql.FieldContext{
 7581		Object:   "OperationEdge",
 7582		Field:    field,
 7583		Args:     nil,
 7584		IsMethod: false,
 7585	}
 7586
 7587	ctx = graphql.WithFieldContext(ctx, fc)
 7588	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7589		ctx = rctx // use context from middleware stack in children
 7590		return obj.Node, nil
 7591	})
 7592	if err != nil {
 7593		ec.Error(ctx, err)
 7594		return graphql.Null
 7595	}
 7596	if resTmp == nil {
 7597		if !graphql.HasFieldError(ctx, fc) {
 7598			ec.Errorf(ctx, "must not be null")
 7599		}
 7600		return graphql.Null
 7601	}
 7602	res := resTmp.(bug.Operation)
 7603	fc.Result = res
 7604	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7605}
 7606
 7607func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7608	defer func() {
 7609		if r := recover(); r != nil {
 7610			ec.Error(ctx, ec.Recover(ctx, r))
 7611			ret = graphql.Null
 7612		}
 7613	}()
 7614	fc := &graphql.FieldContext{
 7615		Object:   "PageInfo",
 7616		Field:    field,
 7617		Args:     nil,
 7618		IsMethod: false,
 7619	}
 7620
 7621	ctx = graphql.WithFieldContext(ctx, fc)
 7622	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7623		ctx = rctx // use context from middleware stack in children
 7624		return obj.HasNextPage, nil
 7625	})
 7626	if err != nil {
 7627		ec.Error(ctx, err)
 7628		return graphql.Null
 7629	}
 7630	if resTmp == nil {
 7631		if !graphql.HasFieldError(ctx, fc) {
 7632			ec.Errorf(ctx, "must not be null")
 7633		}
 7634		return graphql.Null
 7635	}
 7636	res := resTmp.(bool)
 7637	fc.Result = res
 7638	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7639}
 7640
 7641func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7642	defer func() {
 7643		if r := recover(); r != nil {
 7644			ec.Error(ctx, ec.Recover(ctx, r))
 7645			ret = graphql.Null
 7646		}
 7647	}()
 7648	fc := &graphql.FieldContext{
 7649		Object:   "PageInfo",
 7650		Field:    field,
 7651		Args:     nil,
 7652		IsMethod: false,
 7653	}
 7654
 7655	ctx = graphql.WithFieldContext(ctx, fc)
 7656	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7657		ctx = rctx // use context from middleware stack in children
 7658		return obj.HasPreviousPage, nil
 7659	})
 7660	if err != nil {
 7661		ec.Error(ctx, err)
 7662		return graphql.Null
 7663	}
 7664	if resTmp == nil {
 7665		if !graphql.HasFieldError(ctx, fc) {
 7666			ec.Errorf(ctx, "must not be null")
 7667		}
 7668		return graphql.Null
 7669	}
 7670	res := resTmp.(bool)
 7671	fc.Result = res
 7672	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7673}
 7674
 7675func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7676	defer func() {
 7677		if r := recover(); r != nil {
 7678			ec.Error(ctx, ec.Recover(ctx, r))
 7679			ret = graphql.Null
 7680		}
 7681	}()
 7682	fc := &graphql.FieldContext{
 7683		Object:   "PageInfo",
 7684		Field:    field,
 7685		Args:     nil,
 7686		IsMethod: false,
 7687	}
 7688
 7689	ctx = graphql.WithFieldContext(ctx, fc)
 7690	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7691		ctx = rctx // use context from middleware stack in children
 7692		return obj.StartCursor, nil
 7693	})
 7694	if err != nil {
 7695		ec.Error(ctx, err)
 7696		return graphql.Null
 7697	}
 7698	if resTmp == nil {
 7699		if !graphql.HasFieldError(ctx, fc) {
 7700			ec.Errorf(ctx, "must not be null")
 7701		}
 7702		return graphql.Null
 7703	}
 7704	res := resTmp.(string)
 7705	fc.Result = res
 7706	return ec.marshalNString2string(ctx, field.Selections, res)
 7707}
 7708
 7709func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7710	defer func() {
 7711		if r := recover(); r != nil {
 7712			ec.Error(ctx, ec.Recover(ctx, r))
 7713			ret = graphql.Null
 7714		}
 7715	}()
 7716	fc := &graphql.FieldContext{
 7717		Object:   "PageInfo",
 7718		Field:    field,
 7719		Args:     nil,
 7720		IsMethod: false,
 7721	}
 7722
 7723	ctx = graphql.WithFieldContext(ctx, fc)
 7724	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7725		ctx = rctx // use context from middleware stack in children
 7726		return obj.EndCursor, nil
 7727	})
 7728	if err != nil {
 7729		ec.Error(ctx, err)
 7730		return graphql.Null
 7731	}
 7732	if resTmp == nil {
 7733		if !graphql.HasFieldError(ctx, fc) {
 7734			ec.Errorf(ctx, "must not be null")
 7735		}
 7736		return graphql.Null
 7737	}
 7738	res := resTmp.(string)
 7739	fc.Result = res
 7740	return ec.marshalNString2string(ctx, field.Selections, res)
 7741}
 7742
 7743func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7744	defer func() {
 7745		if r := recover(); r != nil {
 7746			ec.Error(ctx, ec.Recover(ctx, r))
 7747			ret = graphql.Null
 7748		}
 7749	}()
 7750	fc := &graphql.FieldContext{
 7751		Object:   "Query",
 7752		Field:    field,
 7753		Args:     nil,
 7754		IsMethod: true,
 7755	}
 7756
 7757	ctx = graphql.WithFieldContext(ctx, fc)
 7758	rawArgs := field.ArgumentMap(ec.Variables)
 7759	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7760	if err != nil {
 7761		ec.Error(ctx, err)
 7762		return graphql.Null
 7763	}
 7764	fc.Args = args
 7765	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7766		ctx = rctx // use context from middleware stack in children
 7767		return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
 7768	})
 7769	if err != nil {
 7770		ec.Error(ctx, err)
 7771		return graphql.Null
 7772	}
 7773	if resTmp == nil {
 7774		return graphql.Null
 7775	}
 7776	res := resTmp.(*models.Repository)
 7777	fc.Result = res
 7778	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7779}
 7780
 7781func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7782	defer func() {
 7783		if r := recover(); r != nil {
 7784			ec.Error(ctx, ec.Recover(ctx, r))
 7785			ret = graphql.Null
 7786		}
 7787	}()
 7788	fc := &graphql.FieldContext{
 7789		Object:   "Query",
 7790		Field:    field,
 7791		Args:     nil,
 7792		IsMethod: true,
 7793	}
 7794
 7795	ctx = graphql.WithFieldContext(ctx, fc)
 7796	rawArgs := field.ArgumentMap(ec.Variables)
 7797	args, err := ec.field_Query___type_args(ctx, rawArgs)
 7798	if err != nil {
 7799		ec.Error(ctx, err)
 7800		return graphql.Null
 7801	}
 7802	fc.Args = args
 7803	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7804		ctx = rctx // use context from middleware stack in children
 7805		return ec.introspectType(args["name"].(string))
 7806	})
 7807	if err != nil {
 7808		ec.Error(ctx, err)
 7809		return graphql.Null
 7810	}
 7811	if resTmp == nil {
 7812		return graphql.Null
 7813	}
 7814	res := resTmp.(*introspection.Type)
 7815	fc.Result = res
 7816	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7817}
 7818
 7819func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7820	defer func() {
 7821		if r := recover(); r != nil {
 7822			ec.Error(ctx, ec.Recover(ctx, r))
 7823			ret = graphql.Null
 7824		}
 7825	}()
 7826	fc := &graphql.FieldContext{
 7827		Object:   "Query",
 7828		Field:    field,
 7829		Args:     nil,
 7830		IsMethod: true,
 7831	}
 7832
 7833	ctx = graphql.WithFieldContext(ctx, fc)
 7834	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7835		ctx = rctx // use context from middleware stack in children
 7836		return ec.introspectSchema()
 7837	})
 7838	if err != nil {
 7839		ec.Error(ctx, err)
 7840		return graphql.Null
 7841	}
 7842	if resTmp == nil {
 7843		return graphql.Null
 7844	}
 7845	res := resTmp.(*introspection.Schema)
 7846	fc.Result = res
 7847	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 7848}
 7849
 7850func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7851	defer func() {
 7852		if r := recover(); r != nil {
 7853			ec.Error(ctx, ec.Recover(ctx, r))
 7854			ret = graphql.Null
 7855		}
 7856	}()
 7857	fc := &graphql.FieldContext{
 7858		Object:   "Repository",
 7859		Field:    field,
 7860		Args:     nil,
 7861		IsMethod: true,
 7862	}
 7863
 7864	ctx = graphql.WithFieldContext(ctx, fc)
 7865	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7866		ctx = rctx // use context from middleware stack in children
 7867		return ec.resolvers.Repository().Name(rctx, obj)
 7868	})
 7869	if err != nil {
 7870		ec.Error(ctx, err)
 7871		return graphql.Null
 7872	}
 7873	if resTmp == nil {
 7874		return graphql.Null
 7875	}
 7876	res := resTmp.(*string)
 7877	fc.Result = res
 7878	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7879}
 7880
 7881func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7882	defer func() {
 7883		if r := recover(); r != nil {
 7884			ec.Error(ctx, ec.Recover(ctx, r))
 7885			ret = graphql.Null
 7886		}
 7887	}()
 7888	fc := &graphql.FieldContext{
 7889		Object:   "Repository",
 7890		Field:    field,
 7891		Args:     nil,
 7892		IsMethod: true,
 7893	}
 7894
 7895	ctx = graphql.WithFieldContext(ctx, fc)
 7896	rawArgs := field.ArgumentMap(ec.Variables)
 7897	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 7898	if err != nil {
 7899		ec.Error(ctx, err)
 7900		return graphql.Null
 7901	}
 7902	fc.Args = args
 7903	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7904		ctx = rctx // use context from middleware stack in children
 7905		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 7906	})
 7907	if err != nil {
 7908		ec.Error(ctx, err)
 7909		return graphql.Null
 7910	}
 7911	if resTmp == nil {
 7912		if !graphql.HasFieldError(ctx, fc) {
 7913			ec.Errorf(ctx, "must not be null")
 7914		}
 7915		return graphql.Null
 7916	}
 7917	res := resTmp.(*models.BugConnection)
 7918	fc.Result = res
 7919	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 7920}
 7921
 7922func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7923	defer func() {
 7924		if r := recover(); r != nil {
 7925			ec.Error(ctx, ec.Recover(ctx, r))
 7926			ret = graphql.Null
 7927		}
 7928	}()
 7929	fc := &graphql.FieldContext{
 7930		Object:   "Repository",
 7931		Field:    field,
 7932		Args:     nil,
 7933		IsMethod: true,
 7934	}
 7935
 7936	ctx = graphql.WithFieldContext(ctx, fc)
 7937	rawArgs := field.ArgumentMap(ec.Variables)
 7938	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 7939	if err != nil {
 7940		ec.Error(ctx, err)
 7941		return graphql.Null
 7942	}
 7943	fc.Args = args
 7944	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7945		ctx = rctx // use context from middleware stack in children
 7946		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 7947	})
 7948	if err != nil {
 7949		ec.Error(ctx, err)
 7950		return graphql.Null
 7951	}
 7952	if resTmp == nil {
 7953		return graphql.Null
 7954	}
 7955	res := resTmp.(models.BugWrapper)
 7956	fc.Result = res
 7957	return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7958}
 7959
 7960func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7961	defer func() {
 7962		if r := recover(); r != nil {
 7963			ec.Error(ctx, ec.Recover(ctx, r))
 7964			ret = graphql.Null
 7965		}
 7966	}()
 7967	fc := &graphql.FieldContext{
 7968		Object:   "Repository",
 7969		Field:    field,
 7970		Args:     nil,
 7971		IsMethod: true,
 7972	}
 7973
 7974	ctx = graphql.WithFieldContext(ctx, fc)
 7975	rawArgs := field.ArgumentMap(ec.Variables)
 7976	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 7977	if err != nil {
 7978		ec.Error(ctx, err)
 7979		return graphql.Null
 7980	}
 7981	fc.Args = args
 7982	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7983		ctx = rctx // use context from middleware stack in children
 7984		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 7985	})
 7986	if err != nil {
 7987		ec.Error(ctx, err)
 7988		return graphql.Null
 7989	}
 7990	if resTmp == nil {
 7991		if !graphql.HasFieldError(ctx, fc) {
 7992			ec.Errorf(ctx, "must not be null")
 7993		}
 7994		return graphql.Null
 7995	}
 7996	res := resTmp.(*models.IdentityConnection)
 7997	fc.Result = res
 7998	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 7999}
 8000
 8001func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8002	defer func() {
 8003		if r := recover(); r != nil {
 8004			ec.Error(ctx, ec.Recover(ctx, r))
 8005			ret = graphql.Null
 8006		}
 8007	}()
 8008	fc := &graphql.FieldContext{
 8009		Object:   "Repository",
 8010		Field:    field,
 8011		Args:     nil,
 8012		IsMethod: true,
 8013	}
 8014
 8015	ctx = graphql.WithFieldContext(ctx, fc)
 8016	rawArgs := field.ArgumentMap(ec.Variables)
 8017	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 8018	if err != nil {
 8019		ec.Error(ctx, err)
 8020		return graphql.Null
 8021	}
 8022	fc.Args = args
 8023	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8024		ctx = rctx // use context from middleware stack in children
 8025		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 8026	})
 8027	if err != nil {
 8028		ec.Error(ctx, err)
 8029		return graphql.Null
 8030	}
 8031	if resTmp == nil {
 8032		return graphql.Null
 8033	}
 8034	res := resTmp.(models.IdentityWrapper)
 8035	fc.Result = res
 8036	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8037}
 8038
 8039func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8040	defer func() {
 8041		if r := recover(); r != nil {
 8042			ec.Error(ctx, ec.Recover(ctx, r))
 8043			ret = graphql.Null
 8044		}
 8045	}()
 8046	fc := &graphql.FieldContext{
 8047		Object:   "Repository",
 8048		Field:    field,
 8049		Args:     nil,
 8050		IsMethod: true,
 8051	}
 8052
 8053	ctx = graphql.WithFieldContext(ctx, fc)
 8054	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8055		ctx = rctx // use context from middleware stack in children
 8056		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 8057	})
 8058	if err != nil {
 8059		ec.Error(ctx, err)
 8060		return graphql.Null
 8061	}
 8062	if resTmp == nil {
 8063		return graphql.Null
 8064	}
 8065	res := resTmp.(models.IdentityWrapper)
 8066	fc.Result = res
 8067	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8068}
 8069
 8070func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8071	defer func() {
 8072		if r := recover(); r != nil {
 8073			ec.Error(ctx, ec.Recover(ctx, r))
 8074			ret = graphql.Null
 8075		}
 8076	}()
 8077	fc := &graphql.FieldContext{
 8078		Object:   "Repository",
 8079		Field:    field,
 8080		Args:     nil,
 8081		IsMethod: true,
 8082	}
 8083
 8084	ctx = graphql.WithFieldContext(ctx, fc)
 8085	rawArgs := field.ArgumentMap(ec.Variables)
 8086	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 8087	if err != nil {
 8088		ec.Error(ctx, err)
 8089		return graphql.Null
 8090	}
 8091	fc.Args = args
 8092	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8093		ctx = rctx // use context from middleware stack in children
 8094		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8095	})
 8096	if err != nil {
 8097		ec.Error(ctx, err)
 8098		return graphql.Null
 8099	}
 8100	if resTmp == nil {
 8101		if !graphql.HasFieldError(ctx, fc) {
 8102			ec.Errorf(ctx, "must not be null")
 8103		}
 8104		return graphql.Null
 8105	}
 8106	res := resTmp.(*models.LabelConnection)
 8107	fc.Result = res
 8108	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 8109}
 8110
 8111func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8112	defer func() {
 8113		if r := recover(); r != nil {
 8114			ec.Error(ctx, ec.Recover(ctx, r))
 8115			ret = graphql.Null
 8116		}
 8117	}()
 8118	fc := &graphql.FieldContext{
 8119		Object:   "SetStatusOperation",
 8120		Field:    field,
 8121		Args:     nil,
 8122		IsMethod: true,
 8123	}
 8124
 8125	ctx = graphql.WithFieldContext(ctx, fc)
 8126	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8127		ctx = rctx // use context from middleware stack in children
 8128		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 8129	})
 8130	if err != nil {
 8131		ec.Error(ctx, err)
 8132		return graphql.Null
 8133	}
 8134	if resTmp == nil {
 8135		if !graphql.HasFieldError(ctx, fc) {
 8136			ec.Errorf(ctx, "must not be null")
 8137		}
 8138		return graphql.Null
 8139	}
 8140	res := resTmp.(string)
 8141	fc.Result = res
 8142	return ec.marshalNString2string(ctx, field.Selections, res)
 8143}
 8144
 8145func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8146	defer func() {
 8147		if r := recover(); r != nil {
 8148			ec.Error(ctx, ec.Recover(ctx, r))
 8149			ret = graphql.Null
 8150		}
 8151	}()
 8152	fc := &graphql.FieldContext{
 8153		Object:   "SetStatusOperation",
 8154		Field:    field,
 8155		Args:     nil,
 8156		IsMethod: true,
 8157	}
 8158
 8159	ctx = graphql.WithFieldContext(ctx, fc)
 8160	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8161		ctx = rctx // use context from middleware stack in children
 8162		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
 8163	})
 8164	if err != nil {
 8165		ec.Error(ctx, err)
 8166		return graphql.Null
 8167	}
 8168	if resTmp == nil {
 8169		if !graphql.HasFieldError(ctx, fc) {
 8170			ec.Errorf(ctx, "must not be null")
 8171		}
 8172		return graphql.Null
 8173	}
 8174	res := resTmp.(models.IdentityWrapper)
 8175	fc.Result = res
 8176	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8177}
 8178
 8179func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8180	defer func() {
 8181		if r := recover(); r != nil {
 8182			ec.Error(ctx, ec.Recover(ctx, r))
 8183			ret = graphql.Null
 8184		}
 8185	}()
 8186	fc := &graphql.FieldContext{
 8187		Object:   "SetStatusOperation",
 8188		Field:    field,
 8189		Args:     nil,
 8190		IsMethod: true,
 8191	}
 8192
 8193	ctx = graphql.WithFieldContext(ctx, fc)
 8194	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8195		ctx = rctx // use context from middleware stack in children
 8196		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 8197	})
 8198	if err != nil {
 8199		ec.Error(ctx, err)
 8200		return graphql.Null
 8201	}
 8202	if resTmp == nil {
 8203		if !graphql.HasFieldError(ctx, fc) {
 8204			ec.Errorf(ctx, "must not be null")
 8205		}
 8206		return graphql.Null
 8207	}
 8208	res := resTmp.(*time.Time)
 8209	fc.Result = res
 8210	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8211}
 8212
 8213func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8214	defer func() {
 8215		if r := recover(); r != nil {
 8216			ec.Error(ctx, ec.Recover(ctx, r))
 8217			ret = graphql.Null
 8218		}
 8219	}()
 8220	fc := &graphql.FieldContext{
 8221		Object:   "SetStatusOperation",
 8222		Field:    field,
 8223		Args:     nil,
 8224		IsMethod: true,
 8225	}
 8226
 8227	ctx = graphql.WithFieldContext(ctx, fc)
 8228	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8229		ctx = rctx // use context from middleware stack in children
 8230		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8231	})
 8232	if err != nil {
 8233		ec.Error(ctx, err)
 8234		return graphql.Null
 8235	}
 8236	if resTmp == nil {
 8237		if !graphql.HasFieldError(ctx, fc) {
 8238			ec.Errorf(ctx, "must not be null")
 8239		}
 8240		return graphql.Null
 8241	}
 8242	res := resTmp.(models.Status)
 8243	fc.Result = res
 8244	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8245}
 8246
 8247func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8248	defer func() {
 8249		if r := recover(); r != nil {
 8250			ec.Error(ctx, ec.Recover(ctx, r))
 8251			ret = graphql.Null
 8252		}
 8253	}()
 8254	fc := &graphql.FieldContext{
 8255		Object:   "SetStatusTimelineItem",
 8256		Field:    field,
 8257		Args:     nil,
 8258		IsMethod: true,
 8259	}
 8260
 8261	ctx = graphql.WithFieldContext(ctx, fc)
 8262	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8263		ctx = rctx // use context from middleware stack in children
 8264		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8265	})
 8266	if err != nil {
 8267		ec.Error(ctx, err)
 8268		return graphql.Null
 8269	}
 8270	if resTmp == nil {
 8271		if !graphql.HasFieldError(ctx, fc) {
 8272			ec.Errorf(ctx, "must not be null")
 8273		}
 8274		return graphql.Null
 8275	}
 8276	res := resTmp.(string)
 8277	fc.Result = res
 8278	return ec.marshalNString2string(ctx, field.Selections, res)
 8279}
 8280
 8281func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8282	defer func() {
 8283		if r := recover(); r != nil {
 8284			ec.Error(ctx, ec.Recover(ctx, r))
 8285			ret = graphql.Null
 8286		}
 8287	}()
 8288	fc := &graphql.FieldContext{
 8289		Object:   "SetStatusTimelineItem",
 8290		Field:    field,
 8291		Args:     nil,
 8292		IsMethod: true,
 8293	}
 8294
 8295	ctx = graphql.WithFieldContext(ctx, fc)
 8296	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8297		ctx = rctx // use context from middleware stack in children
 8298		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
 8299	})
 8300	if err != nil {
 8301		ec.Error(ctx, err)
 8302		return graphql.Null
 8303	}
 8304	if resTmp == nil {
 8305		if !graphql.HasFieldError(ctx, fc) {
 8306			ec.Errorf(ctx, "must not be null")
 8307		}
 8308		return graphql.Null
 8309	}
 8310	res := resTmp.(models.IdentityWrapper)
 8311	fc.Result = res
 8312	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8313}
 8314
 8315func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8316	defer func() {
 8317		if r := recover(); r != nil {
 8318			ec.Error(ctx, ec.Recover(ctx, r))
 8319			ret = graphql.Null
 8320		}
 8321	}()
 8322	fc := &graphql.FieldContext{
 8323		Object:   "SetStatusTimelineItem",
 8324		Field:    field,
 8325		Args:     nil,
 8326		IsMethod: true,
 8327	}
 8328
 8329	ctx = graphql.WithFieldContext(ctx, fc)
 8330	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8331		ctx = rctx // use context from middleware stack in children
 8332		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8333	})
 8334	if err != nil {
 8335		ec.Error(ctx, err)
 8336		return graphql.Null
 8337	}
 8338	if resTmp == nil {
 8339		if !graphql.HasFieldError(ctx, fc) {
 8340			ec.Errorf(ctx, "must not be null")
 8341		}
 8342		return graphql.Null
 8343	}
 8344	res := resTmp.(*time.Time)
 8345	fc.Result = res
 8346	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8347}
 8348
 8349func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8350	defer func() {
 8351		if r := recover(); r != nil {
 8352			ec.Error(ctx, ec.Recover(ctx, r))
 8353			ret = graphql.Null
 8354		}
 8355	}()
 8356	fc := &graphql.FieldContext{
 8357		Object:   "SetStatusTimelineItem",
 8358		Field:    field,
 8359		Args:     nil,
 8360		IsMethod: true,
 8361	}
 8362
 8363	ctx = graphql.WithFieldContext(ctx, fc)
 8364	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8365		ctx = rctx // use context from middleware stack in children
 8366		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8367	})
 8368	if err != nil {
 8369		ec.Error(ctx, err)
 8370		return graphql.Null
 8371	}
 8372	if resTmp == nil {
 8373		if !graphql.HasFieldError(ctx, fc) {
 8374			ec.Errorf(ctx, "must not be null")
 8375		}
 8376		return graphql.Null
 8377	}
 8378	res := resTmp.(models.Status)
 8379	fc.Result = res
 8380	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8381}
 8382
 8383func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8384	defer func() {
 8385		if r := recover(); r != nil {
 8386			ec.Error(ctx, ec.Recover(ctx, r))
 8387			ret = graphql.Null
 8388		}
 8389	}()
 8390	fc := &graphql.FieldContext{
 8391		Object:   "SetTitleOperation",
 8392		Field:    field,
 8393		Args:     nil,
 8394		IsMethod: true,
 8395	}
 8396
 8397	ctx = graphql.WithFieldContext(ctx, fc)
 8398	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8399		ctx = rctx // use context from middleware stack in children
 8400		return ec.resolvers.SetTitleOperation().ID(rctx, obj)
 8401	})
 8402	if err != nil {
 8403		ec.Error(ctx, err)
 8404		return graphql.Null
 8405	}
 8406	if resTmp == nil {
 8407		if !graphql.HasFieldError(ctx, fc) {
 8408			ec.Errorf(ctx, "must not be null")
 8409		}
 8410		return graphql.Null
 8411	}
 8412	res := resTmp.(string)
 8413	fc.Result = res
 8414	return ec.marshalNString2string(ctx, field.Selections, res)
 8415}
 8416
 8417func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8418	defer func() {
 8419		if r := recover(); r != nil {
 8420			ec.Error(ctx, ec.Recover(ctx, r))
 8421			ret = graphql.Null
 8422		}
 8423	}()
 8424	fc := &graphql.FieldContext{
 8425		Object:   "SetTitleOperation",
 8426		Field:    field,
 8427		Args:     nil,
 8428		IsMethod: true,
 8429	}
 8430
 8431	ctx = graphql.WithFieldContext(ctx, fc)
 8432	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8433		ctx = rctx // use context from middleware stack in children
 8434		return ec.resolvers.SetTitleOperation().Author(rctx, obj)
 8435	})
 8436	if err != nil {
 8437		ec.Error(ctx, err)
 8438		return graphql.Null
 8439	}
 8440	if resTmp == nil {
 8441		if !graphql.HasFieldError(ctx, fc) {
 8442			ec.Errorf(ctx, "must not be null")
 8443		}
 8444		return graphql.Null
 8445	}
 8446	res := resTmp.(models.IdentityWrapper)
 8447	fc.Result = res
 8448	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8449}
 8450
 8451func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8452	defer func() {
 8453		if r := recover(); r != nil {
 8454			ec.Error(ctx, ec.Recover(ctx, r))
 8455			ret = graphql.Null
 8456		}
 8457	}()
 8458	fc := &graphql.FieldContext{
 8459		Object:   "SetTitleOperation",
 8460		Field:    field,
 8461		Args:     nil,
 8462		IsMethod: true,
 8463	}
 8464
 8465	ctx = graphql.WithFieldContext(ctx, fc)
 8466	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8467		ctx = rctx // use context from middleware stack in children
 8468		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8469	})
 8470	if err != nil {
 8471		ec.Error(ctx, err)
 8472		return graphql.Null
 8473	}
 8474	if resTmp == nil {
 8475		if !graphql.HasFieldError(ctx, fc) {
 8476			ec.Errorf(ctx, "must not be null")
 8477		}
 8478		return graphql.Null
 8479	}
 8480	res := resTmp.(*time.Time)
 8481	fc.Result = res
 8482	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8483}
 8484
 8485func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8486	defer func() {
 8487		if r := recover(); r != nil {
 8488			ec.Error(ctx, ec.Recover(ctx, r))
 8489			ret = graphql.Null
 8490		}
 8491	}()
 8492	fc := &graphql.FieldContext{
 8493		Object:   "SetTitleOperation",
 8494		Field:    field,
 8495		Args:     nil,
 8496		IsMethod: false,
 8497	}
 8498
 8499	ctx = graphql.WithFieldContext(ctx, fc)
 8500	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8501		ctx = rctx // use context from middleware stack in children
 8502		return obj.Title, nil
 8503	})
 8504	if err != nil {
 8505		ec.Error(ctx, err)
 8506		return graphql.Null
 8507	}
 8508	if resTmp == nil {
 8509		if !graphql.HasFieldError(ctx, fc) {
 8510			ec.Errorf(ctx, "must not be null")
 8511		}
 8512		return graphql.Null
 8513	}
 8514	res := resTmp.(string)
 8515	fc.Result = res
 8516	return ec.marshalNString2string(ctx, field.Selections, res)
 8517}
 8518
 8519func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8520	defer func() {
 8521		if r := recover(); r != nil {
 8522			ec.Error(ctx, ec.Recover(ctx, r))
 8523			ret = graphql.Null
 8524		}
 8525	}()
 8526	fc := &graphql.FieldContext{
 8527		Object:   "SetTitleOperation",
 8528		Field:    field,
 8529		Args:     nil,
 8530		IsMethod: false,
 8531	}
 8532
 8533	ctx = graphql.WithFieldContext(ctx, fc)
 8534	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8535		ctx = rctx // use context from middleware stack in children
 8536		return obj.Was, nil
 8537	})
 8538	if err != nil {
 8539		ec.Error(ctx, err)
 8540		return graphql.Null
 8541	}
 8542	if resTmp == nil {
 8543		if !graphql.HasFieldError(ctx, fc) {
 8544			ec.Errorf(ctx, "must not be null")
 8545		}
 8546		return graphql.Null
 8547	}
 8548	res := resTmp.(string)
 8549	fc.Result = res
 8550	return ec.marshalNString2string(ctx, field.Selections, res)
 8551}
 8552
 8553func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8554	defer func() {
 8555		if r := recover(); r != nil {
 8556			ec.Error(ctx, ec.Recover(ctx, r))
 8557			ret = graphql.Null
 8558		}
 8559	}()
 8560	fc := &graphql.FieldContext{
 8561		Object:   "SetTitlePayload",
 8562		Field:    field,
 8563		Args:     nil,
 8564		IsMethod: false,
 8565	}
 8566
 8567	ctx = graphql.WithFieldContext(ctx, fc)
 8568	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8569		ctx = rctx // use context from middleware stack in children
 8570		return obj.ClientMutationID, nil
 8571	})
 8572	if err != nil {
 8573		ec.Error(ctx, err)
 8574		return graphql.Null
 8575	}
 8576	if resTmp == nil {
 8577		return graphql.Null
 8578	}
 8579	res := resTmp.(*string)
 8580	fc.Result = res
 8581	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8582}
 8583
 8584func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8585	defer func() {
 8586		if r := recover(); r != nil {
 8587			ec.Error(ctx, ec.Recover(ctx, r))
 8588			ret = graphql.Null
 8589		}
 8590	}()
 8591	fc := &graphql.FieldContext{
 8592		Object:   "SetTitlePayload",
 8593		Field:    field,
 8594		Args:     nil,
 8595		IsMethod: false,
 8596	}
 8597
 8598	ctx = graphql.WithFieldContext(ctx, fc)
 8599	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8600		ctx = rctx // use context from middleware stack in children
 8601		return obj.Bug, nil
 8602	})
 8603	if err != nil {
 8604		ec.Error(ctx, err)
 8605		return graphql.Null
 8606	}
 8607	if resTmp == nil {
 8608		if !graphql.HasFieldError(ctx, fc) {
 8609			ec.Errorf(ctx, "must not be null")
 8610		}
 8611		return graphql.Null
 8612	}
 8613	res := resTmp.(models.BugWrapper)
 8614	fc.Result = res
 8615	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 8616}
 8617
 8618func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8619	defer func() {
 8620		if r := recover(); r != nil {
 8621			ec.Error(ctx, ec.Recover(ctx, r))
 8622			ret = graphql.Null
 8623		}
 8624	}()
 8625	fc := &graphql.FieldContext{
 8626		Object:   "SetTitlePayload",
 8627		Field:    field,
 8628		Args:     nil,
 8629		IsMethod: false,
 8630	}
 8631
 8632	ctx = graphql.WithFieldContext(ctx, fc)
 8633	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8634		ctx = rctx // use context from middleware stack in children
 8635		return obj.Operation, nil
 8636	})
 8637	if err != nil {
 8638		ec.Error(ctx, err)
 8639		return graphql.Null
 8640	}
 8641	if resTmp == nil {
 8642		if !graphql.HasFieldError(ctx, fc) {
 8643			ec.Errorf(ctx, "must not be null")
 8644		}
 8645		return graphql.Null
 8646	}
 8647	res := resTmp.(*bug.SetTitleOperation)
 8648	fc.Result = res
 8649	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8650}
 8651
 8652func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8653	defer func() {
 8654		if r := recover(); r != nil {
 8655			ec.Error(ctx, ec.Recover(ctx, r))
 8656			ret = graphql.Null
 8657		}
 8658	}()
 8659	fc := &graphql.FieldContext{
 8660		Object:   "SetTitleTimelineItem",
 8661		Field:    field,
 8662		Args:     nil,
 8663		IsMethod: true,
 8664	}
 8665
 8666	ctx = graphql.WithFieldContext(ctx, fc)
 8667	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8668		ctx = rctx // use context from middleware stack in children
 8669		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8670	})
 8671	if err != nil {
 8672		ec.Error(ctx, err)
 8673		return graphql.Null
 8674	}
 8675	if resTmp == nil {
 8676		if !graphql.HasFieldError(ctx, fc) {
 8677			ec.Errorf(ctx, "must not be null")
 8678		}
 8679		return graphql.Null
 8680	}
 8681	res := resTmp.(string)
 8682	fc.Result = res
 8683	return ec.marshalNString2string(ctx, field.Selections, res)
 8684}
 8685
 8686func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8687	defer func() {
 8688		if r := recover(); r != nil {
 8689			ec.Error(ctx, ec.Recover(ctx, r))
 8690			ret = graphql.Null
 8691		}
 8692	}()
 8693	fc := &graphql.FieldContext{
 8694		Object:   "SetTitleTimelineItem",
 8695		Field:    field,
 8696		Args:     nil,
 8697		IsMethod: true,
 8698	}
 8699
 8700	ctx = graphql.WithFieldContext(ctx, fc)
 8701	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8702		ctx = rctx // use context from middleware stack in children
 8703		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
 8704	})
 8705	if err != nil {
 8706		ec.Error(ctx, err)
 8707		return graphql.Null
 8708	}
 8709	if resTmp == nil {
 8710		if !graphql.HasFieldError(ctx, fc) {
 8711			ec.Errorf(ctx, "must not be null")
 8712		}
 8713		return graphql.Null
 8714	}
 8715	res := resTmp.(models.IdentityWrapper)
 8716	fc.Result = res
 8717	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8718}
 8719
 8720func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8721	defer func() {
 8722		if r := recover(); r != nil {
 8723			ec.Error(ctx, ec.Recover(ctx, r))
 8724			ret = graphql.Null
 8725		}
 8726	}()
 8727	fc := &graphql.FieldContext{
 8728		Object:   "SetTitleTimelineItem",
 8729		Field:    field,
 8730		Args:     nil,
 8731		IsMethod: true,
 8732	}
 8733
 8734	ctx = graphql.WithFieldContext(ctx, fc)
 8735	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8736		ctx = rctx // use context from middleware stack in children
 8737		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8738	})
 8739	if err != nil {
 8740		ec.Error(ctx, err)
 8741		return graphql.Null
 8742	}
 8743	if resTmp == nil {
 8744		if !graphql.HasFieldError(ctx, fc) {
 8745			ec.Errorf(ctx, "must not be null")
 8746		}
 8747		return graphql.Null
 8748	}
 8749	res := resTmp.(*time.Time)
 8750	fc.Result = res
 8751	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8752}
 8753
 8754func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8755	defer func() {
 8756		if r := recover(); r != nil {
 8757			ec.Error(ctx, ec.Recover(ctx, r))
 8758			ret = graphql.Null
 8759		}
 8760	}()
 8761	fc := &graphql.FieldContext{
 8762		Object:   "SetTitleTimelineItem",
 8763		Field:    field,
 8764		Args:     nil,
 8765		IsMethod: false,
 8766	}
 8767
 8768	ctx = graphql.WithFieldContext(ctx, fc)
 8769	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8770		ctx = rctx // use context from middleware stack in children
 8771		return obj.Title, nil
 8772	})
 8773	if err != nil {
 8774		ec.Error(ctx, err)
 8775		return graphql.Null
 8776	}
 8777	if resTmp == nil {
 8778		if !graphql.HasFieldError(ctx, fc) {
 8779			ec.Errorf(ctx, "must not be null")
 8780		}
 8781		return graphql.Null
 8782	}
 8783	res := resTmp.(string)
 8784	fc.Result = res
 8785	return ec.marshalNString2string(ctx, field.Selections, res)
 8786}
 8787
 8788func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8789	defer func() {
 8790		if r := recover(); r != nil {
 8791			ec.Error(ctx, ec.Recover(ctx, r))
 8792			ret = graphql.Null
 8793		}
 8794	}()
 8795	fc := &graphql.FieldContext{
 8796		Object:   "SetTitleTimelineItem",
 8797		Field:    field,
 8798		Args:     nil,
 8799		IsMethod: false,
 8800	}
 8801
 8802	ctx = graphql.WithFieldContext(ctx, fc)
 8803	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8804		ctx = rctx // use context from middleware stack in children
 8805		return obj.Was, nil
 8806	})
 8807	if err != nil {
 8808		ec.Error(ctx, err)
 8809		return graphql.Null
 8810	}
 8811	if resTmp == nil {
 8812		if !graphql.HasFieldError(ctx, fc) {
 8813			ec.Errorf(ctx, "must not be null")
 8814		}
 8815		return graphql.Null
 8816	}
 8817	res := resTmp.(string)
 8818	fc.Result = res
 8819	return ec.marshalNString2string(ctx, field.Selections, res)
 8820}
 8821
 8822func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8823	defer func() {
 8824		if r := recover(); r != nil {
 8825			ec.Error(ctx, ec.Recover(ctx, r))
 8826			ret = graphql.Null
 8827		}
 8828	}()
 8829	fc := &graphql.FieldContext{
 8830		Object:   "TimelineItemConnection",
 8831		Field:    field,
 8832		Args:     nil,
 8833		IsMethod: false,
 8834	}
 8835
 8836	ctx = graphql.WithFieldContext(ctx, fc)
 8837	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8838		ctx = rctx // use context from middleware stack in children
 8839		return obj.Edges, nil
 8840	})
 8841	if err != nil {
 8842		ec.Error(ctx, err)
 8843		return graphql.Null
 8844	}
 8845	if resTmp == nil {
 8846		if !graphql.HasFieldError(ctx, fc) {
 8847			ec.Errorf(ctx, "must not be null")
 8848		}
 8849		return graphql.Null
 8850	}
 8851	res := resTmp.([]*models.TimelineItemEdge)
 8852	fc.Result = res
 8853	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 8854}
 8855
 8856func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8857	defer func() {
 8858		if r := recover(); r != nil {
 8859			ec.Error(ctx, ec.Recover(ctx, r))
 8860			ret = graphql.Null
 8861		}
 8862	}()
 8863	fc := &graphql.FieldContext{
 8864		Object:   "TimelineItemConnection",
 8865		Field:    field,
 8866		Args:     nil,
 8867		IsMethod: false,
 8868	}
 8869
 8870	ctx = graphql.WithFieldContext(ctx, fc)
 8871	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8872		ctx = rctx // use context from middleware stack in children
 8873		return obj.Nodes, nil
 8874	})
 8875	if err != nil {
 8876		ec.Error(ctx, err)
 8877		return graphql.Null
 8878	}
 8879	if resTmp == nil {
 8880		if !graphql.HasFieldError(ctx, fc) {
 8881			ec.Errorf(ctx, "must not be null")
 8882		}
 8883		return graphql.Null
 8884	}
 8885	res := resTmp.([]bug.TimelineItem)
 8886	fc.Result = res
 8887	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 8888}
 8889
 8890func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8891	defer func() {
 8892		if r := recover(); r != nil {
 8893			ec.Error(ctx, ec.Recover(ctx, r))
 8894			ret = graphql.Null
 8895		}
 8896	}()
 8897	fc := &graphql.FieldContext{
 8898		Object:   "TimelineItemConnection",
 8899		Field:    field,
 8900		Args:     nil,
 8901		IsMethod: false,
 8902	}
 8903
 8904	ctx = graphql.WithFieldContext(ctx, fc)
 8905	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8906		ctx = rctx // use context from middleware stack in children
 8907		return obj.PageInfo, nil
 8908	})
 8909	if err != nil {
 8910		ec.Error(ctx, err)
 8911		return graphql.Null
 8912	}
 8913	if resTmp == nil {
 8914		if !graphql.HasFieldError(ctx, fc) {
 8915			ec.Errorf(ctx, "must not be null")
 8916		}
 8917		return graphql.Null
 8918	}
 8919	res := resTmp.(*models.PageInfo)
 8920	fc.Result = res
 8921	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 8922}
 8923
 8924func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8925	defer func() {
 8926		if r := recover(); r != nil {
 8927			ec.Error(ctx, ec.Recover(ctx, r))
 8928			ret = graphql.Null
 8929		}
 8930	}()
 8931	fc := &graphql.FieldContext{
 8932		Object:   "TimelineItemConnection",
 8933		Field:    field,
 8934		Args:     nil,
 8935		IsMethod: false,
 8936	}
 8937
 8938	ctx = graphql.WithFieldContext(ctx, fc)
 8939	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8940		ctx = rctx // use context from middleware stack in children
 8941		return obj.TotalCount, nil
 8942	})
 8943	if err != nil {
 8944		ec.Error(ctx, err)
 8945		return graphql.Null
 8946	}
 8947	if resTmp == nil {
 8948		if !graphql.HasFieldError(ctx, fc) {
 8949			ec.Errorf(ctx, "must not be null")
 8950		}
 8951		return graphql.Null
 8952	}
 8953	res := resTmp.(int)
 8954	fc.Result = res
 8955	return ec.marshalNInt2int(ctx, field.Selections, res)
 8956}
 8957
 8958func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8959	defer func() {
 8960		if r := recover(); r != nil {
 8961			ec.Error(ctx, ec.Recover(ctx, r))
 8962			ret = graphql.Null
 8963		}
 8964	}()
 8965	fc := &graphql.FieldContext{
 8966		Object:   "TimelineItemEdge",
 8967		Field:    field,
 8968		Args:     nil,
 8969		IsMethod: false,
 8970	}
 8971
 8972	ctx = graphql.WithFieldContext(ctx, fc)
 8973	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8974		ctx = rctx // use context from middleware stack in children
 8975		return obj.Cursor, nil
 8976	})
 8977	if err != nil {
 8978		ec.Error(ctx, err)
 8979		return graphql.Null
 8980	}
 8981	if resTmp == nil {
 8982		if !graphql.HasFieldError(ctx, fc) {
 8983			ec.Errorf(ctx, "must not be null")
 8984		}
 8985		return graphql.Null
 8986	}
 8987	res := resTmp.(string)
 8988	fc.Result = res
 8989	return ec.marshalNString2string(ctx, field.Selections, res)
 8990}
 8991
 8992func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8993	defer func() {
 8994		if r := recover(); r != nil {
 8995			ec.Error(ctx, ec.Recover(ctx, r))
 8996			ret = graphql.Null
 8997		}
 8998	}()
 8999	fc := &graphql.FieldContext{
 9000		Object:   "TimelineItemEdge",
 9001		Field:    field,
 9002		Args:     nil,
 9003		IsMethod: false,
 9004	}
 9005
 9006	ctx = graphql.WithFieldContext(ctx, fc)
 9007	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9008		ctx = rctx // use context from middleware stack in children
 9009		return obj.Node, nil
 9010	})
 9011	if err != nil {
 9012		ec.Error(ctx, err)
 9013		return graphql.Null
 9014	}
 9015	if resTmp == nil {
 9016		if !graphql.HasFieldError(ctx, fc) {
 9017			ec.Errorf(ctx, "must not be null")
 9018		}
 9019		return graphql.Null
 9020	}
 9021	res := resTmp.(bug.TimelineItem)
 9022	fc.Result = res
 9023	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 9024}
 9025
 9026func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9027	defer func() {
 9028		if r := recover(); r != nil {
 9029			ec.Error(ctx, ec.Recover(ctx, r))
 9030			ret = graphql.Null
 9031		}
 9032	}()
 9033	fc := &graphql.FieldContext{
 9034		Object:   "__Directive",
 9035		Field:    field,
 9036		Args:     nil,
 9037		IsMethod: false,
 9038	}
 9039
 9040	ctx = graphql.WithFieldContext(ctx, fc)
 9041	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9042		ctx = rctx // use context from middleware stack in children
 9043		return obj.Name, nil
 9044	})
 9045	if err != nil {
 9046		ec.Error(ctx, err)
 9047		return graphql.Null
 9048	}
 9049	if resTmp == nil {
 9050		if !graphql.HasFieldError(ctx, fc) {
 9051			ec.Errorf(ctx, "must not be null")
 9052		}
 9053		return graphql.Null
 9054	}
 9055	res := resTmp.(string)
 9056	fc.Result = res
 9057	return ec.marshalNString2string(ctx, field.Selections, res)
 9058}
 9059
 9060func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9061	defer func() {
 9062		if r := recover(); r != nil {
 9063			ec.Error(ctx, ec.Recover(ctx, r))
 9064			ret = graphql.Null
 9065		}
 9066	}()
 9067	fc := &graphql.FieldContext{
 9068		Object:   "__Directive",
 9069		Field:    field,
 9070		Args:     nil,
 9071		IsMethod: false,
 9072	}
 9073
 9074	ctx = graphql.WithFieldContext(ctx, fc)
 9075	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9076		ctx = rctx // use context from middleware stack in children
 9077		return obj.Description, nil
 9078	})
 9079	if err != nil {
 9080		ec.Error(ctx, err)
 9081		return graphql.Null
 9082	}
 9083	if resTmp == nil {
 9084		return graphql.Null
 9085	}
 9086	res := resTmp.(string)
 9087	fc.Result = res
 9088	return ec.marshalOString2string(ctx, field.Selections, res)
 9089}
 9090
 9091func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9092	defer func() {
 9093		if r := recover(); r != nil {
 9094			ec.Error(ctx, ec.Recover(ctx, r))
 9095			ret = graphql.Null
 9096		}
 9097	}()
 9098	fc := &graphql.FieldContext{
 9099		Object:   "__Directive",
 9100		Field:    field,
 9101		Args:     nil,
 9102		IsMethod: false,
 9103	}
 9104
 9105	ctx = graphql.WithFieldContext(ctx, fc)
 9106	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9107		ctx = rctx // use context from middleware stack in children
 9108		return obj.Locations, nil
 9109	})
 9110	if err != nil {
 9111		ec.Error(ctx, err)
 9112		return graphql.Null
 9113	}
 9114	if resTmp == nil {
 9115		if !graphql.HasFieldError(ctx, fc) {
 9116			ec.Errorf(ctx, "must not be null")
 9117		}
 9118		return graphql.Null
 9119	}
 9120	res := resTmp.([]string)
 9121	fc.Result = res
 9122	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 9123}
 9124
 9125func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9126	defer func() {
 9127		if r := recover(); r != nil {
 9128			ec.Error(ctx, ec.Recover(ctx, r))
 9129			ret = graphql.Null
 9130		}
 9131	}()
 9132	fc := &graphql.FieldContext{
 9133		Object:   "__Directive",
 9134		Field:    field,
 9135		Args:     nil,
 9136		IsMethod: false,
 9137	}
 9138
 9139	ctx = graphql.WithFieldContext(ctx, fc)
 9140	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9141		ctx = rctx // use context from middleware stack in children
 9142		return obj.Args, nil
 9143	})
 9144	if err != nil {
 9145		ec.Error(ctx, err)
 9146		return graphql.Null
 9147	}
 9148	if resTmp == nil {
 9149		if !graphql.HasFieldError(ctx, fc) {
 9150			ec.Errorf(ctx, "must not be null")
 9151		}
 9152		return graphql.Null
 9153	}
 9154	res := resTmp.([]introspection.InputValue)
 9155	fc.Result = res
 9156	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9157}
 9158
 9159func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9160	defer func() {
 9161		if r := recover(); r != nil {
 9162			ec.Error(ctx, ec.Recover(ctx, r))
 9163			ret = graphql.Null
 9164		}
 9165	}()
 9166	fc := &graphql.FieldContext{
 9167		Object:   "__EnumValue",
 9168		Field:    field,
 9169		Args:     nil,
 9170		IsMethod: false,
 9171	}
 9172
 9173	ctx = graphql.WithFieldContext(ctx, fc)
 9174	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9175		ctx = rctx // use context from middleware stack in children
 9176		return obj.Name, nil
 9177	})
 9178	if err != nil {
 9179		ec.Error(ctx, err)
 9180		return graphql.Null
 9181	}
 9182	if resTmp == nil {
 9183		if !graphql.HasFieldError(ctx, fc) {
 9184			ec.Errorf(ctx, "must not be null")
 9185		}
 9186		return graphql.Null
 9187	}
 9188	res := resTmp.(string)
 9189	fc.Result = res
 9190	return ec.marshalNString2string(ctx, field.Selections, res)
 9191}
 9192
 9193func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9194	defer func() {
 9195		if r := recover(); r != nil {
 9196			ec.Error(ctx, ec.Recover(ctx, r))
 9197			ret = graphql.Null
 9198		}
 9199	}()
 9200	fc := &graphql.FieldContext{
 9201		Object:   "__EnumValue",
 9202		Field:    field,
 9203		Args:     nil,
 9204		IsMethod: false,
 9205	}
 9206
 9207	ctx = graphql.WithFieldContext(ctx, fc)
 9208	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9209		ctx = rctx // use context from middleware stack in children
 9210		return obj.Description, nil
 9211	})
 9212	if err != nil {
 9213		ec.Error(ctx, err)
 9214		return graphql.Null
 9215	}
 9216	if resTmp == nil {
 9217		return graphql.Null
 9218	}
 9219	res := resTmp.(string)
 9220	fc.Result = res
 9221	return ec.marshalOString2string(ctx, field.Selections, res)
 9222}
 9223
 9224func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9225	defer func() {
 9226		if r := recover(); r != nil {
 9227			ec.Error(ctx, ec.Recover(ctx, r))
 9228			ret = graphql.Null
 9229		}
 9230	}()
 9231	fc := &graphql.FieldContext{
 9232		Object:   "__EnumValue",
 9233		Field:    field,
 9234		Args:     nil,
 9235		IsMethod: true,
 9236	}
 9237
 9238	ctx = graphql.WithFieldContext(ctx, fc)
 9239	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9240		ctx = rctx // use context from middleware stack in children
 9241		return obj.IsDeprecated(), nil
 9242	})
 9243	if err != nil {
 9244		ec.Error(ctx, err)
 9245		return graphql.Null
 9246	}
 9247	if resTmp == nil {
 9248		if !graphql.HasFieldError(ctx, fc) {
 9249			ec.Errorf(ctx, "must not be null")
 9250		}
 9251		return graphql.Null
 9252	}
 9253	res := resTmp.(bool)
 9254	fc.Result = res
 9255	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9256}
 9257
 9258func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9259	defer func() {
 9260		if r := recover(); r != nil {
 9261			ec.Error(ctx, ec.Recover(ctx, r))
 9262			ret = graphql.Null
 9263		}
 9264	}()
 9265	fc := &graphql.FieldContext{
 9266		Object:   "__EnumValue",
 9267		Field:    field,
 9268		Args:     nil,
 9269		IsMethod: true,
 9270	}
 9271
 9272	ctx = graphql.WithFieldContext(ctx, fc)
 9273	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9274		ctx = rctx // use context from middleware stack in children
 9275		return obj.DeprecationReason(), nil
 9276	})
 9277	if err != nil {
 9278		ec.Error(ctx, err)
 9279		return graphql.Null
 9280	}
 9281	if resTmp == nil {
 9282		return graphql.Null
 9283	}
 9284	res := resTmp.(*string)
 9285	fc.Result = res
 9286	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9287}
 9288
 9289func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9290	defer func() {
 9291		if r := recover(); r != nil {
 9292			ec.Error(ctx, ec.Recover(ctx, r))
 9293			ret = graphql.Null
 9294		}
 9295	}()
 9296	fc := &graphql.FieldContext{
 9297		Object:   "__Field",
 9298		Field:    field,
 9299		Args:     nil,
 9300		IsMethod: false,
 9301	}
 9302
 9303	ctx = graphql.WithFieldContext(ctx, fc)
 9304	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9305		ctx = rctx // use context from middleware stack in children
 9306		return obj.Name, nil
 9307	})
 9308	if err != nil {
 9309		ec.Error(ctx, err)
 9310		return graphql.Null
 9311	}
 9312	if resTmp == nil {
 9313		if !graphql.HasFieldError(ctx, fc) {
 9314			ec.Errorf(ctx, "must not be null")
 9315		}
 9316		return graphql.Null
 9317	}
 9318	res := resTmp.(string)
 9319	fc.Result = res
 9320	return ec.marshalNString2string(ctx, field.Selections, res)
 9321}
 9322
 9323func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9324	defer func() {
 9325		if r := recover(); r != nil {
 9326			ec.Error(ctx, ec.Recover(ctx, r))
 9327			ret = graphql.Null
 9328		}
 9329	}()
 9330	fc := &graphql.FieldContext{
 9331		Object:   "__Field",
 9332		Field:    field,
 9333		Args:     nil,
 9334		IsMethod: false,
 9335	}
 9336
 9337	ctx = graphql.WithFieldContext(ctx, fc)
 9338	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9339		ctx = rctx // use context from middleware stack in children
 9340		return obj.Description, nil
 9341	})
 9342	if err != nil {
 9343		ec.Error(ctx, err)
 9344		return graphql.Null
 9345	}
 9346	if resTmp == nil {
 9347		return graphql.Null
 9348	}
 9349	res := resTmp.(string)
 9350	fc.Result = res
 9351	return ec.marshalOString2string(ctx, field.Selections, res)
 9352}
 9353
 9354func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9355	defer func() {
 9356		if r := recover(); r != nil {
 9357			ec.Error(ctx, ec.Recover(ctx, r))
 9358			ret = graphql.Null
 9359		}
 9360	}()
 9361	fc := &graphql.FieldContext{
 9362		Object:   "__Field",
 9363		Field:    field,
 9364		Args:     nil,
 9365		IsMethod: false,
 9366	}
 9367
 9368	ctx = graphql.WithFieldContext(ctx, fc)
 9369	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9370		ctx = rctx // use context from middleware stack in children
 9371		return obj.Args, nil
 9372	})
 9373	if err != nil {
 9374		ec.Error(ctx, err)
 9375		return graphql.Null
 9376	}
 9377	if resTmp == nil {
 9378		if !graphql.HasFieldError(ctx, fc) {
 9379			ec.Errorf(ctx, "must not be null")
 9380		}
 9381		return graphql.Null
 9382	}
 9383	res := resTmp.([]introspection.InputValue)
 9384	fc.Result = res
 9385	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9386}
 9387
 9388func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9389	defer func() {
 9390		if r := recover(); r != nil {
 9391			ec.Error(ctx, ec.Recover(ctx, r))
 9392			ret = graphql.Null
 9393		}
 9394	}()
 9395	fc := &graphql.FieldContext{
 9396		Object:   "__Field",
 9397		Field:    field,
 9398		Args:     nil,
 9399		IsMethod: false,
 9400	}
 9401
 9402	ctx = graphql.WithFieldContext(ctx, fc)
 9403	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9404		ctx = rctx // use context from middleware stack in children
 9405		return obj.Type, nil
 9406	})
 9407	if err != nil {
 9408		ec.Error(ctx, err)
 9409		return graphql.Null
 9410	}
 9411	if resTmp == nil {
 9412		if !graphql.HasFieldError(ctx, fc) {
 9413			ec.Errorf(ctx, "must not be null")
 9414		}
 9415		return graphql.Null
 9416	}
 9417	res := resTmp.(*introspection.Type)
 9418	fc.Result = res
 9419	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9420}
 9421
 9422func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9423	defer func() {
 9424		if r := recover(); r != nil {
 9425			ec.Error(ctx, ec.Recover(ctx, r))
 9426			ret = graphql.Null
 9427		}
 9428	}()
 9429	fc := &graphql.FieldContext{
 9430		Object:   "__Field",
 9431		Field:    field,
 9432		Args:     nil,
 9433		IsMethod: true,
 9434	}
 9435
 9436	ctx = graphql.WithFieldContext(ctx, fc)
 9437	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9438		ctx = rctx // use context from middleware stack in children
 9439		return obj.IsDeprecated(), nil
 9440	})
 9441	if err != nil {
 9442		ec.Error(ctx, err)
 9443		return graphql.Null
 9444	}
 9445	if resTmp == nil {
 9446		if !graphql.HasFieldError(ctx, fc) {
 9447			ec.Errorf(ctx, "must not be null")
 9448		}
 9449		return graphql.Null
 9450	}
 9451	res := resTmp.(bool)
 9452	fc.Result = res
 9453	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9454}
 9455
 9456func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9457	defer func() {
 9458		if r := recover(); r != nil {
 9459			ec.Error(ctx, ec.Recover(ctx, r))
 9460			ret = graphql.Null
 9461		}
 9462	}()
 9463	fc := &graphql.FieldContext{
 9464		Object:   "__Field",
 9465		Field:    field,
 9466		Args:     nil,
 9467		IsMethod: true,
 9468	}
 9469
 9470	ctx = graphql.WithFieldContext(ctx, fc)
 9471	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9472		ctx = rctx // use context from middleware stack in children
 9473		return obj.DeprecationReason(), nil
 9474	})
 9475	if err != nil {
 9476		ec.Error(ctx, err)
 9477		return graphql.Null
 9478	}
 9479	if resTmp == nil {
 9480		return graphql.Null
 9481	}
 9482	res := resTmp.(*string)
 9483	fc.Result = res
 9484	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9485}
 9486
 9487func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9488	defer func() {
 9489		if r := recover(); r != nil {
 9490			ec.Error(ctx, ec.Recover(ctx, r))
 9491			ret = graphql.Null
 9492		}
 9493	}()
 9494	fc := &graphql.FieldContext{
 9495		Object:   "__InputValue",
 9496		Field:    field,
 9497		Args:     nil,
 9498		IsMethod: false,
 9499	}
 9500
 9501	ctx = graphql.WithFieldContext(ctx, fc)
 9502	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9503		ctx = rctx // use context from middleware stack in children
 9504		return obj.Name, nil
 9505	})
 9506	if err != nil {
 9507		ec.Error(ctx, err)
 9508		return graphql.Null
 9509	}
 9510	if resTmp == nil {
 9511		if !graphql.HasFieldError(ctx, fc) {
 9512			ec.Errorf(ctx, "must not be null")
 9513		}
 9514		return graphql.Null
 9515	}
 9516	res := resTmp.(string)
 9517	fc.Result = res
 9518	return ec.marshalNString2string(ctx, field.Selections, res)
 9519}
 9520
 9521func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9522	defer func() {
 9523		if r := recover(); r != nil {
 9524			ec.Error(ctx, ec.Recover(ctx, r))
 9525			ret = graphql.Null
 9526		}
 9527	}()
 9528	fc := &graphql.FieldContext{
 9529		Object:   "__InputValue",
 9530		Field:    field,
 9531		Args:     nil,
 9532		IsMethod: false,
 9533	}
 9534
 9535	ctx = graphql.WithFieldContext(ctx, fc)
 9536	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9537		ctx = rctx // use context from middleware stack in children
 9538		return obj.Description, nil
 9539	})
 9540	if err != nil {
 9541		ec.Error(ctx, err)
 9542		return graphql.Null
 9543	}
 9544	if resTmp == nil {
 9545		return graphql.Null
 9546	}
 9547	res := resTmp.(string)
 9548	fc.Result = res
 9549	return ec.marshalOString2string(ctx, field.Selections, res)
 9550}
 9551
 9552func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9553	defer func() {
 9554		if r := recover(); r != nil {
 9555			ec.Error(ctx, ec.Recover(ctx, r))
 9556			ret = graphql.Null
 9557		}
 9558	}()
 9559	fc := &graphql.FieldContext{
 9560		Object:   "__InputValue",
 9561		Field:    field,
 9562		Args:     nil,
 9563		IsMethod: false,
 9564	}
 9565
 9566	ctx = graphql.WithFieldContext(ctx, fc)
 9567	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9568		ctx = rctx // use context from middleware stack in children
 9569		return obj.Type, nil
 9570	})
 9571	if err != nil {
 9572		ec.Error(ctx, err)
 9573		return graphql.Null
 9574	}
 9575	if resTmp == nil {
 9576		if !graphql.HasFieldError(ctx, fc) {
 9577			ec.Errorf(ctx, "must not be null")
 9578		}
 9579		return graphql.Null
 9580	}
 9581	res := resTmp.(*introspection.Type)
 9582	fc.Result = res
 9583	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9584}
 9585
 9586func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9587	defer func() {
 9588		if r := recover(); r != nil {
 9589			ec.Error(ctx, ec.Recover(ctx, r))
 9590			ret = graphql.Null
 9591		}
 9592	}()
 9593	fc := &graphql.FieldContext{
 9594		Object:   "__InputValue",
 9595		Field:    field,
 9596		Args:     nil,
 9597		IsMethod: false,
 9598	}
 9599
 9600	ctx = graphql.WithFieldContext(ctx, fc)
 9601	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9602		ctx = rctx // use context from middleware stack in children
 9603		return obj.DefaultValue, nil
 9604	})
 9605	if err != nil {
 9606		ec.Error(ctx, err)
 9607		return graphql.Null
 9608	}
 9609	if resTmp == nil {
 9610		return graphql.Null
 9611	}
 9612	res := resTmp.(*string)
 9613	fc.Result = res
 9614	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9615}
 9616
 9617func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9618	defer func() {
 9619		if r := recover(); r != nil {
 9620			ec.Error(ctx, ec.Recover(ctx, r))
 9621			ret = graphql.Null
 9622		}
 9623	}()
 9624	fc := &graphql.FieldContext{
 9625		Object:   "__Schema",
 9626		Field:    field,
 9627		Args:     nil,
 9628		IsMethod: true,
 9629	}
 9630
 9631	ctx = graphql.WithFieldContext(ctx, fc)
 9632	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9633		ctx = rctx // use context from middleware stack in children
 9634		return obj.Types(), nil
 9635	})
 9636	if err != nil {
 9637		ec.Error(ctx, err)
 9638		return graphql.Null
 9639	}
 9640	if resTmp == nil {
 9641		if !graphql.HasFieldError(ctx, fc) {
 9642			ec.Errorf(ctx, "must not be null")
 9643		}
 9644		return graphql.Null
 9645	}
 9646	res := resTmp.([]introspection.Type)
 9647	fc.Result = res
 9648	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9649}
 9650
 9651func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9652	defer func() {
 9653		if r := recover(); r != nil {
 9654			ec.Error(ctx, ec.Recover(ctx, r))
 9655			ret = graphql.Null
 9656		}
 9657	}()
 9658	fc := &graphql.FieldContext{
 9659		Object:   "__Schema",
 9660		Field:    field,
 9661		Args:     nil,
 9662		IsMethod: true,
 9663	}
 9664
 9665	ctx = graphql.WithFieldContext(ctx, fc)
 9666	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9667		ctx = rctx // use context from middleware stack in children
 9668		return obj.QueryType(), nil
 9669	})
 9670	if err != nil {
 9671		ec.Error(ctx, err)
 9672		return graphql.Null
 9673	}
 9674	if resTmp == nil {
 9675		if !graphql.HasFieldError(ctx, fc) {
 9676			ec.Errorf(ctx, "must not be null")
 9677		}
 9678		return graphql.Null
 9679	}
 9680	res := resTmp.(*introspection.Type)
 9681	fc.Result = res
 9682	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9683}
 9684
 9685func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9686	defer func() {
 9687		if r := recover(); r != nil {
 9688			ec.Error(ctx, ec.Recover(ctx, r))
 9689			ret = graphql.Null
 9690		}
 9691	}()
 9692	fc := &graphql.FieldContext{
 9693		Object:   "__Schema",
 9694		Field:    field,
 9695		Args:     nil,
 9696		IsMethod: true,
 9697	}
 9698
 9699	ctx = graphql.WithFieldContext(ctx, fc)
 9700	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9701		ctx = rctx // use context from middleware stack in children
 9702		return obj.MutationType(), nil
 9703	})
 9704	if err != nil {
 9705		ec.Error(ctx, err)
 9706		return graphql.Null
 9707	}
 9708	if resTmp == nil {
 9709		return graphql.Null
 9710	}
 9711	res := resTmp.(*introspection.Type)
 9712	fc.Result = res
 9713	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9714}
 9715
 9716func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9717	defer func() {
 9718		if r := recover(); r != nil {
 9719			ec.Error(ctx, ec.Recover(ctx, r))
 9720			ret = graphql.Null
 9721		}
 9722	}()
 9723	fc := &graphql.FieldContext{
 9724		Object:   "__Schema",
 9725		Field:    field,
 9726		Args:     nil,
 9727		IsMethod: true,
 9728	}
 9729
 9730	ctx = graphql.WithFieldContext(ctx, fc)
 9731	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9732		ctx = rctx // use context from middleware stack in children
 9733		return obj.SubscriptionType(), nil
 9734	})
 9735	if err != nil {
 9736		ec.Error(ctx, err)
 9737		return graphql.Null
 9738	}
 9739	if resTmp == nil {
 9740		return graphql.Null
 9741	}
 9742	res := resTmp.(*introspection.Type)
 9743	fc.Result = res
 9744	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9745}
 9746
 9747func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9748	defer func() {
 9749		if r := recover(); r != nil {
 9750			ec.Error(ctx, ec.Recover(ctx, r))
 9751			ret = graphql.Null
 9752		}
 9753	}()
 9754	fc := &graphql.FieldContext{
 9755		Object:   "__Schema",
 9756		Field:    field,
 9757		Args:     nil,
 9758		IsMethod: true,
 9759	}
 9760
 9761	ctx = graphql.WithFieldContext(ctx, fc)
 9762	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9763		ctx = rctx // use context from middleware stack in children
 9764		return obj.Directives(), nil
 9765	})
 9766	if err != nil {
 9767		ec.Error(ctx, err)
 9768		return graphql.Null
 9769	}
 9770	if resTmp == nil {
 9771		if !graphql.HasFieldError(ctx, fc) {
 9772			ec.Errorf(ctx, "must not be null")
 9773		}
 9774		return graphql.Null
 9775	}
 9776	res := resTmp.([]introspection.Directive)
 9777	fc.Result = res
 9778	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
 9779}
 9780
 9781func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9782	defer func() {
 9783		if r := recover(); r != nil {
 9784			ec.Error(ctx, ec.Recover(ctx, r))
 9785			ret = graphql.Null
 9786		}
 9787	}()
 9788	fc := &graphql.FieldContext{
 9789		Object:   "__Type",
 9790		Field:    field,
 9791		Args:     nil,
 9792		IsMethod: true,
 9793	}
 9794
 9795	ctx = graphql.WithFieldContext(ctx, fc)
 9796	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9797		ctx = rctx // use context from middleware stack in children
 9798		return obj.Kind(), nil
 9799	})
 9800	if err != nil {
 9801		ec.Error(ctx, err)
 9802		return graphql.Null
 9803	}
 9804	if resTmp == nil {
 9805		if !graphql.HasFieldError(ctx, fc) {
 9806			ec.Errorf(ctx, "must not be null")
 9807		}
 9808		return graphql.Null
 9809	}
 9810	res := resTmp.(string)
 9811	fc.Result = res
 9812	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 9813}
 9814
 9815func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9816	defer func() {
 9817		if r := recover(); r != nil {
 9818			ec.Error(ctx, ec.Recover(ctx, r))
 9819			ret = graphql.Null
 9820		}
 9821	}()
 9822	fc := &graphql.FieldContext{
 9823		Object:   "__Type",
 9824		Field:    field,
 9825		Args:     nil,
 9826		IsMethod: true,
 9827	}
 9828
 9829	ctx = graphql.WithFieldContext(ctx, fc)
 9830	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9831		ctx = rctx // use context from middleware stack in children
 9832		return obj.Name(), nil
 9833	})
 9834	if err != nil {
 9835		ec.Error(ctx, err)
 9836		return graphql.Null
 9837	}
 9838	if resTmp == nil {
 9839		return graphql.Null
 9840	}
 9841	res := resTmp.(*string)
 9842	fc.Result = res
 9843	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9844}
 9845
 9846func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9847	defer func() {
 9848		if r := recover(); r != nil {
 9849			ec.Error(ctx, ec.Recover(ctx, r))
 9850			ret = graphql.Null
 9851		}
 9852	}()
 9853	fc := &graphql.FieldContext{
 9854		Object:   "__Type",
 9855		Field:    field,
 9856		Args:     nil,
 9857		IsMethod: true,
 9858	}
 9859
 9860	ctx = graphql.WithFieldContext(ctx, fc)
 9861	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9862		ctx = rctx // use context from middleware stack in children
 9863		return obj.Description(), nil
 9864	})
 9865	if err != nil {
 9866		ec.Error(ctx, err)
 9867		return graphql.Null
 9868	}
 9869	if resTmp == nil {
 9870		return graphql.Null
 9871	}
 9872	res := resTmp.(string)
 9873	fc.Result = res
 9874	return ec.marshalOString2string(ctx, field.Selections, res)
 9875}
 9876
 9877func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9878	defer func() {
 9879		if r := recover(); r != nil {
 9880			ec.Error(ctx, ec.Recover(ctx, r))
 9881			ret = graphql.Null
 9882		}
 9883	}()
 9884	fc := &graphql.FieldContext{
 9885		Object:   "__Type",
 9886		Field:    field,
 9887		Args:     nil,
 9888		IsMethod: true,
 9889	}
 9890
 9891	ctx = graphql.WithFieldContext(ctx, fc)
 9892	rawArgs := field.ArgumentMap(ec.Variables)
 9893	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 9894	if err != nil {
 9895		ec.Error(ctx, err)
 9896		return graphql.Null
 9897	}
 9898	fc.Args = args
 9899	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9900		ctx = rctx // use context from middleware stack in children
 9901		return obj.Fields(args["includeDeprecated"].(bool)), nil
 9902	})
 9903	if err != nil {
 9904		ec.Error(ctx, err)
 9905		return graphql.Null
 9906	}
 9907	if resTmp == nil {
 9908		return graphql.Null
 9909	}
 9910	res := resTmp.([]introspection.Field)
 9911	fc.Result = res
 9912	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
 9913}
 9914
 9915func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9916	defer func() {
 9917		if r := recover(); r != nil {
 9918			ec.Error(ctx, ec.Recover(ctx, r))
 9919			ret = graphql.Null
 9920		}
 9921	}()
 9922	fc := &graphql.FieldContext{
 9923		Object:   "__Type",
 9924		Field:    field,
 9925		Args:     nil,
 9926		IsMethod: true,
 9927	}
 9928
 9929	ctx = graphql.WithFieldContext(ctx, fc)
 9930	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9931		ctx = rctx // use context from middleware stack in children
 9932		return obj.Interfaces(), nil
 9933	})
 9934	if err != nil {
 9935		ec.Error(ctx, err)
 9936		return graphql.Null
 9937	}
 9938	if resTmp == nil {
 9939		return graphql.Null
 9940	}
 9941	res := resTmp.([]introspection.Type)
 9942	fc.Result = res
 9943	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9944}
 9945
 9946func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9947	defer func() {
 9948		if r := recover(); r != nil {
 9949			ec.Error(ctx, ec.Recover(ctx, r))
 9950			ret = graphql.Null
 9951		}
 9952	}()
 9953	fc := &graphql.FieldContext{
 9954		Object:   "__Type",
 9955		Field:    field,
 9956		Args:     nil,
 9957		IsMethod: true,
 9958	}
 9959
 9960	ctx = graphql.WithFieldContext(ctx, fc)
 9961	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9962		ctx = rctx // use context from middleware stack in children
 9963		return obj.PossibleTypes(), nil
 9964	})
 9965	if err != nil {
 9966		ec.Error(ctx, err)
 9967		return graphql.Null
 9968	}
 9969	if resTmp == nil {
 9970		return graphql.Null
 9971	}
 9972	res := resTmp.([]introspection.Type)
 9973	fc.Result = res
 9974	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9975}
 9976
 9977func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9978	defer func() {
 9979		if r := recover(); r != nil {
 9980			ec.Error(ctx, ec.Recover(ctx, r))
 9981			ret = graphql.Null
 9982		}
 9983	}()
 9984	fc := &graphql.FieldContext{
 9985		Object:   "__Type",
 9986		Field:    field,
 9987		Args:     nil,
 9988		IsMethod: true,
 9989	}
 9990
 9991	ctx = graphql.WithFieldContext(ctx, fc)
 9992	rawArgs := field.ArgumentMap(ec.Variables)
 9993	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
 9994	if err != nil {
 9995		ec.Error(ctx, err)
 9996		return graphql.Null
 9997	}
 9998	fc.Args = args
 9999	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10000		ctx = rctx // use context from middleware stack in children
10001		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10002	})
10003	if err != nil {
10004		ec.Error(ctx, err)
10005		return graphql.Null
10006	}
10007	if resTmp == nil {
10008		return graphql.Null
10009	}
10010	res := resTmp.([]introspection.EnumValue)
10011	fc.Result = res
10012	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10013}
10014
10015func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10016	defer func() {
10017		if r := recover(); r != nil {
10018			ec.Error(ctx, ec.Recover(ctx, r))
10019			ret = graphql.Null
10020		}
10021	}()
10022	fc := &graphql.FieldContext{
10023		Object:   "__Type",
10024		Field:    field,
10025		Args:     nil,
10026		IsMethod: true,
10027	}
10028
10029	ctx = graphql.WithFieldContext(ctx, fc)
10030	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10031		ctx = rctx // use context from middleware stack in children
10032		return obj.InputFields(), nil
10033	})
10034	if err != nil {
10035		ec.Error(ctx, err)
10036		return graphql.Null
10037	}
10038	if resTmp == nil {
10039		return graphql.Null
10040	}
10041	res := resTmp.([]introspection.InputValue)
10042	fc.Result = res
10043	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10044}
10045
10046func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10047	defer func() {
10048		if r := recover(); r != nil {
10049			ec.Error(ctx, ec.Recover(ctx, r))
10050			ret = graphql.Null
10051		}
10052	}()
10053	fc := &graphql.FieldContext{
10054		Object:   "__Type",
10055		Field:    field,
10056		Args:     nil,
10057		IsMethod: true,
10058	}
10059
10060	ctx = graphql.WithFieldContext(ctx, fc)
10061	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10062		ctx = rctx // use context from middleware stack in children
10063		return obj.OfType(), nil
10064	})
10065	if err != nil {
10066		ec.Error(ctx, err)
10067		return graphql.Null
10068	}
10069	if resTmp == nil {
10070		return graphql.Null
10071	}
10072	res := resTmp.(*introspection.Type)
10073	fc.Result = res
10074	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10075}
10076
10077// endregion **************************** field.gotpl *****************************
10078
10079// region    **************************** input.gotpl *****************************
10080
10081func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10082	var it models.AddCommentInput
10083	var asMap = obj.(map[string]interface{})
10084
10085	for k, v := range asMap {
10086		switch k {
10087		case "clientMutationId":
10088			var err error
10089			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10090			if err != nil {
10091				return it, err
10092			}
10093		case "repoRef":
10094			var err error
10095			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10096			if err != nil {
10097				return it, err
10098			}
10099		case "prefix":
10100			var err error
10101			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10102			if err != nil {
10103				return it, err
10104			}
10105		case "message":
10106			var err error
10107			it.Message, err = ec.unmarshalNString2string(ctx, v)
10108			if err != nil {
10109				return it, err
10110			}
10111		case "files":
10112			var err error
10113			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10114			if err != nil {
10115				return it, err
10116			}
10117		}
10118	}
10119
10120	return it, nil
10121}
10122
10123func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10124	var it models.ChangeLabelInput
10125	var asMap = obj.(map[string]interface{})
10126
10127	for k, v := range asMap {
10128		switch k {
10129		case "clientMutationId":
10130			var err error
10131			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10132			if err != nil {
10133				return it, err
10134			}
10135		case "repoRef":
10136			var err error
10137			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10138			if err != nil {
10139				return it, err
10140			}
10141		case "prefix":
10142			var err error
10143			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10144			if err != nil {
10145				return it, err
10146			}
10147		case "added":
10148			var err error
10149			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10150			if err != nil {
10151				return it, err
10152			}
10153		case "Removed":
10154			var err error
10155			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10156			if err != nil {
10157				return it, err
10158			}
10159		}
10160	}
10161
10162	return it, nil
10163}
10164
10165func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10166	var it models.CloseBugInput
10167	var asMap = obj.(map[string]interface{})
10168
10169	for k, v := range asMap {
10170		switch k {
10171		case "clientMutationId":
10172			var err error
10173			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10174			if err != nil {
10175				return it, err
10176			}
10177		case "repoRef":
10178			var err error
10179			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10180			if err != nil {
10181				return it, err
10182			}
10183		case "prefix":
10184			var err error
10185			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10186			if err != nil {
10187				return it, err
10188			}
10189		}
10190	}
10191
10192	return it, nil
10193}
10194
10195func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
10196	var it models.EditCommentInput
10197	var asMap = obj.(map[string]interface{})
10198
10199	for k, v := range asMap {
10200		switch k {
10201		case "clientMutationId":
10202			var err error
10203			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10204			if err != nil {
10205				return it, err
10206			}
10207		case "repoRef":
10208			var err error
10209			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10210			if err != nil {
10211				return it, err
10212			}
10213		case "prefix":
10214			var err error
10215			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10216			if err != nil {
10217				return it, err
10218			}
10219		case "target":
10220			var err error
10221			it.Target, err = ec.unmarshalNString2string(ctx, v)
10222			if err != nil {
10223				return it, err
10224			}
10225		case "message":
10226			var err error
10227			it.Message, err = ec.unmarshalNString2string(ctx, v)
10228			if err != nil {
10229				return it, err
10230			}
10231		case "files":
10232			var err error
10233			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10234			if err != nil {
10235				return it, err
10236			}
10237		}
10238	}
10239
10240	return it, nil
10241}
10242
10243func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10244	var it models.NewBugInput
10245	var asMap = obj.(map[string]interface{})
10246
10247	for k, v := range asMap {
10248		switch k {
10249		case "clientMutationId":
10250			var err error
10251			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10252			if err != nil {
10253				return it, err
10254			}
10255		case "repoRef":
10256			var err error
10257			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10258			if err != nil {
10259				return it, err
10260			}
10261		case "title":
10262			var err error
10263			it.Title, err = ec.unmarshalNString2string(ctx, v)
10264			if err != nil {
10265				return it, err
10266			}
10267		case "message":
10268			var err error
10269			it.Message, err = ec.unmarshalNString2string(ctx, v)
10270			if err != nil {
10271				return it, err
10272			}
10273		case "files":
10274			var err error
10275			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
10276			if err != nil {
10277				return it, err
10278			}
10279		}
10280	}
10281
10282	return it, nil
10283}
10284
10285func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10286	var it models.OpenBugInput
10287	var asMap = obj.(map[string]interface{})
10288
10289	for k, v := range asMap {
10290		switch k {
10291		case "clientMutationId":
10292			var err error
10293			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10294			if err != nil {
10295				return it, err
10296			}
10297		case "repoRef":
10298			var err error
10299			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10300			if err != nil {
10301				return it, err
10302			}
10303		case "prefix":
10304			var err error
10305			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10306			if err != nil {
10307				return it, err
10308			}
10309		}
10310	}
10311
10312	return it, nil
10313}
10314
10315func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10316	var it models.SetTitleInput
10317	var asMap = obj.(map[string]interface{})
10318
10319	for k, v := range asMap {
10320		switch k {
10321		case "clientMutationId":
10322			var err error
10323			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10324			if err != nil {
10325				return it, err
10326			}
10327		case "repoRef":
10328			var err error
10329			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10330			if err != nil {
10331				return it, err
10332			}
10333		case "prefix":
10334			var err error
10335			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10336			if err != nil {
10337				return it, err
10338			}
10339		case "title":
10340			var err error
10341			it.Title, err = ec.unmarshalNString2string(ctx, v)
10342			if err != nil {
10343				return it, err
10344			}
10345		}
10346	}
10347
10348	return it, nil
10349}
10350
10351// endregion **************************** input.gotpl *****************************
10352
10353// region    ************************** interface.gotpl ***************************
10354
10355func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10356	switch obj := (obj).(type) {
10357	case nil:
10358		return graphql.Null
10359	case bug.Comment:
10360		return ec._Comment(ctx, sel, &obj)
10361	case *bug.Comment:
10362		if obj == nil {
10363			return graphql.Null
10364		}
10365		return ec._Comment(ctx, sel, obj)
10366	case models.BugWrapper:
10367		if obj == nil {
10368			return graphql.Null
10369		}
10370		return ec._Bug(ctx, sel, obj)
10371	case *bug.CreateOperation:
10372		if obj == nil {
10373			return graphql.Null
10374		}
10375		return ec._CreateOperation(ctx, sel, obj)
10376	case *bug.SetTitleOperation:
10377		if obj == nil {
10378			return graphql.Null
10379		}
10380		return ec._SetTitleOperation(ctx, sel, obj)
10381	case *bug.AddCommentOperation:
10382		if obj == nil {
10383			return graphql.Null
10384		}
10385		return ec._AddCommentOperation(ctx, sel, obj)
10386	case *bug.EditCommentOperation:
10387		if obj == nil {
10388			return graphql.Null
10389		}
10390		return ec._EditCommentOperation(ctx, sel, obj)
10391	case *bug.SetStatusOperation:
10392		if obj == nil {
10393			return graphql.Null
10394		}
10395		return ec._SetStatusOperation(ctx, sel, obj)
10396	case *bug.LabelChangeOperation:
10397		if obj == nil {
10398			return graphql.Null
10399		}
10400		return ec._LabelChangeOperation(ctx, sel, obj)
10401	case *bug.CreateTimelineItem:
10402		if obj == nil {
10403			return graphql.Null
10404		}
10405		return ec._CreateTimelineItem(ctx, sel, obj)
10406	case *bug.AddCommentTimelineItem:
10407		if obj == nil {
10408			return graphql.Null
10409		}
10410		return ec._AddCommentTimelineItem(ctx, sel, obj)
10411	case *bug.LabelChangeTimelineItem:
10412		if obj == nil {
10413			return graphql.Null
10414		}
10415		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10416	case *bug.SetStatusTimelineItem:
10417		if obj == nil {
10418			return graphql.Null
10419		}
10420		return ec._SetStatusTimelineItem(ctx, sel, obj)
10421	case *bug.SetTitleTimelineItem:
10422		if obj == nil {
10423			return graphql.Null
10424		}
10425		return ec._SetTitleTimelineItem(ctx, sel, obj)
10426	default:
10427		panic(fmt.Errorf("unexpected type %T", obj))
10428	}
10429}
10430
10431func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10432	switch obj := (obj).(type) {
10433	case nil:
10434		return graphql.Null
10435	case *bug.CreateOperation:
10436		if obj == nil {
10437			return graphql.Null
10438		}
10439		return ec._CreateOperation(ctx, sel, obj)
10440	case *bug.SetTitleOperation:
10441		if obj == nil {
10442			return graphql.Null
10443		}
10444		return ec._SetTitleOperation(ctx, sel, obj)
10445	case *bug.AddCommentOperation:
10446		if obj == nil {
10447			return graphql.Null
10448		}
10449		return ec._AddCommentOperation(ctx, sel, obj)
10450	case *bug.EditCommentOperation:
10451		if obj == nil {
10452			return graphql.Null
10453		}
10454		return ec._EditCommentOperation(ctx, sel, obj)
10455	case *bug.SetStatusOperation:
10456		if obj == nil {
10457			return graphql.Null
10458		}
10459		return ec._SetStatusOperation(ctx, sel, obj)
10460	case *bug.LabelChangeOperation:
10461		if obj == nil {
10462			return graphql.Null
10463		}
10464		return ec._LabelChangeOperation(ctx, sel, obj)
10465	default:
10466		panic(fmt.Errorf("unexpected type %T", obj))
10467	}
10468}
10469
10470func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10471	switch obj := (obj).(type) {
10472	case nil:
10473		return graphql.Null
10474	case *bug.CreateTimelineItem:
10475		if obj == nil {
10476			return graphql.Null
10477		}
10478		return ec._CreateTimelineItem(ctx, sel, obj)
10479	case *bug.AddCommentTimelineItem:
10480		if obj == nil {
10481			return graphql.Null
10482		}
10483		return ec._AddCommentTimelineItem(ctx, sel, obj)
10484	case bug.LabelChangeTimelineItem:
10485		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10486	case *bug.LabelChangeTimelineItem:
10487		if obj == nil {
10488			return graphql.Null
10489		}
10490		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10491	case bug.SetStatusTimelineItem:
10492		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10493	case *bug.SetStatusTimelineItem:
10494		if obj == nil {
10495			return graphql.Null
10496		}
10497		return ec._SetStatusTimelineItem(ctx, sel, obj)
10498	case bug.SetTitleTimelineItem:
10499		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10500	case *bug.SetTitleTimelineItem:
10501		if obj == nil {
10502			return graphql.Null
10503		}
10504		return ec._SetTitleTimelineItem(ctx, sel, obj)
10505	default:
10506		panic(fmt.Errorf("unexpected type %T", obj))
10507	}
10508}
10509
10510// endregion ************************** interface.gotpl ***************************
10511
10512// region    **************************** object.gotpl ****************************
10513
10514var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10515
10516func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10517	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10518
10519	out := graphql.NewFieldSet(fields)
10520	var invalids uint32
10521	for i, field := range fields {
10522		switch field.Name {
10523		case "__typename":
10524			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10525		case "id":
10526			field := field
10527			out.Concurrently(i, func() (res graphql.Marshaler) {
10528				defer func() {
10529					if r := recover(); r != nil {
10530						ec.Error(ctx, ec.Recover(ctx, r))
10531					}
10532				}()
10533				res = ec._AddCommentOperation_id(ctx, field, obj)
10534				if res == graphql.Null {
10535					atomic.AddUint32(&invalids, 1)
10536				}
10537				return res
10538			})
10539		case "author":
10540			field := field
10541			out.Concurrently(i, func() (res graphql.Marshaler) {
10542				defer func() {
10543					if r := recover(); r != nil {
10544						ec.Error(ctx, ec.Recover(ctx, r))
10545					}
10546				}()
10547				res = ec._AddCommentOperation_author(ctx, field, obj)
10548				if res == graphql.Null {
10549					atomic.AddUint32(&invalids, 1)
10550				}
10551				return res
10552			})
10553		case "date":
10554			field := field
10555			out.Concurrently(i, func() (res graphql.Marshaler) {
10556				defer func() {
10557					if r := recover(); r != nil {
10558						ec.Error(ctx, ec.Recover(ctx, r))
10559					}
10560				}()
10561				res = ec._AddCommentOperation_date(ctx, field, obj)
10562				if res == graphql.Null {
10563					atomic.AddUint32(&invalids, 1)
10564				}
10565				return res
10566			})
10567		case "message":
10568			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10569			if out.Values[i] == graphql.Null {
10570				atomic.AddUint32(&invalids, 1)
10571			}
10572		case "files":
10573			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10574			if out.Values[i] == graphql.Null {
10575				atomic.AddUint32(&invalids, 1)
10576			}
10577		default:
10578			panic("unknown field " + strconv.Quote(field.Name))
10579		}
10580	}
10581	out.Dispatch()
10582	if invalids > 0 {
10583		return graphql.Null
10584	}
10585	return out
10586}
10587
10588var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10589
10590func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10591	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10592
10593	out := graphql.NewFieldSet(fields)
10594	var invalids uint32
10595	for i, field := range fields {
10596		switch field.Name {
10597		case "__typename":
10598			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10599		case "clientMutationId":
10600			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10601		case "bug":
10602			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10603			if out.Values[i] == graphql.Null {
10604				invalids++
10605			}
10606		case "operation":
10607			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10608			if out.Values[i] == graphql.Null {
10609				invalids++
10610			}
10611		default:
10612			panic("unknown field " + strconv.Quote(field.Name))
10613		}
10614	}
10615	out.Dispatch()
10616	if invalids > 0 {
10617		return graphql.Null
10618	}
10619	return out
10620}
10621
10622var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10623
10624func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10625	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10626
10627	out := graphql.NewFieldSet(fields)
10628	var invalids uint32
10629	for i, field := range fields {
10630		switch field.Name {
10631		case "__typename":
10632			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10633		case "id":
10634			field := field
10635			out.Concurrently(i, func() (res graphql.Marshaler) {
10636				defer func() {
10637					if r := recover(); r != nil {
10638						ec.Error(ctx, ec.Recover(ctx, r))
10639					}
10640				}()
10641				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10642				if res == graphql.Null {
10643					atomic.AddUint32(&invalids, 1)
10644				}
10645				return res
10646			})
10647		case "author":
10648			field := field
10649			out.Concurrently(i, func() (res graphql.Marshaler) {
10650				defer func() {
10651					if r := recover(); r != nil {
10652						ec.Error(ctx, ec.Recover(ctx, r))
10653					}
10654				}()
10655				res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10656				if res == graphql.Null {
10657					atomic.AddUint32(&invalids, 1)
10658				}
10659				return res
10660			})
10661		case "message":
10662			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10663			if out.Values[i] == graphql.Null {
10664				atomic.AddUint32(&invalids, 1)
10665			}
10666		case "messageIsEmpty":
10667			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10668			if out.Values[i] == graphql.Null {
10669				atomic.AddUint32(&invalids, 1)
10670			}
10671		case "files":
10672			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10673			if out.Values[i] == graphql.Null {
10674				atomic.AddUint32(&invalids, 1)
10675			}
10676		case "createdAt":
10677			field := field
10678			out.Concurrently(i, func() (res graphql.Marshaler) {
10679				defer func() {
10680					if r := recover(); r != nil {
10681						ec.Error(ctx, ec.Recover(ctx, r))
10682					}
10683				}()
10684				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10685				if res == graphql.Null {
10686					atomic.AddUint32(&invalids, 1)
10687				}
10688				return res
10689			})
10690		case "lastEdit":
10691			field := field
10692			out.Concurrently(i, func() (res graphql.Marshaler) {
10693				defer func() {
10694					if r := recover(); r != nil {
10695						ec.Error(ctx, ec.Recover(ctx, r))
10696					}
10697				}()
10698				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10699				if res == graphql.Null {
10700					atomic.AddUint32(&invalids, 1)
10701				}
10702				return res
10703			})
10704		case "edited":
10705			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10706			if out.Values[i] == graphql.Null {
10707				atomic.AddUint32(&invalids, 1)
10708			}
10709		case "history":
10710			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10711			if out.Values[i] == graphql.Null {
10712				atomic.AddUint32(&invalids, 1)
10713			}
10714		default:
10715			panic("unknown field " + strconv.Quote(field.Name))
10716		}
10717	}
10718	out.Dispatch()
10719	if invalids > 0 {
10720		return graphql.Null
10721	}
10722	return out
10723}
10724
10725var bugImplementors = []string{"Bug", "Authored"}
10726
10727func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10728	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10729
10730	out := graphql.NewFieldSet(fields)
10731	var invalids uint32
10732	for i, field := range fields {
10733		switch field.Name {
10734		case "__typename":
10735			out.Values[i] = graphql.MarshalString("Bug")
10736		case "id":
10737			field := field
10738			out.Concurrently(i, func() (res graphql.Marshaler) {
10739				defer func() {
10740					if r := recover(); r != nil {
10741						ec.Error(ctx, ec.Recover(ctx, r))
10742					}
10743				}()
10744				res = ec._Bug_id(ctx, field, obj)
10745				if res == graphql.Null {
10746					atomic.AddUint32(&invalids, 1)
10747				}
10748				return res
10749			})
10750		case "humanId":
10751			field := field
10752			out.Concurrently(i, func() (res graphql.Marshaler) {
10753				defer func() {
10754					if r := recover(); r != nil {
10755						ec.Error(ctx, ec.Recover(ctx, r))
10756					}
10757				}()
10758				res = ec._Bug_humanId(ctx, field, obj)
10759				if res == graphql.Null {
10760					atomic.AddUint32(&invalids, 1)
10761				}
10762				return res
10763			})
10764		case "status":
10765			field := field
10766			out.Concurrently(i, func() (res graphql.Marshaler) {
10767				defer func() {
10768					if r := recover(); r != nil {
10769						ec.Error(ctx, ec.Recover(ctx, r))
10770					}
10771				}()
10772				res = ec._Bug_status(ctx, field, obj)
10773				if res == graphql.Null {
10774					atomic.AddUint32(&invalids, 1)
10775				}
10776				return res
10777			})
10778		case "title":
10779			out.Values[i] = ec._Bug_title(ctx, field, obj)
10780			if out.Values[i] == graphql.Null {
10781				atomic.AddUint32(&invalids, 1)
10782			}
10783		case "labels":
10784			out.Values[i] = ec._Bug_labels(ctx, field, obj)
10785			if out.Values[i] == graphql.Null {
10786				atomic.AddUint32(&invalids, 1)
10787			}
10788		case "author":
10789			out.Values[i] = ec._Bug_author(ctx, field, obj)
10790			if out.Values[i] == graphql.Null {
10791				atomic.AddUint32(&invalids, 1)
10792			}
10793		case "createdAt":
10794			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10795			if out.Values[i] == graphql.Null {
10796				atomic.AddUint32(&invalids, 1)
10797			}
10798		case "lastEdit":
10799			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10800			if out.Values[i] == graphql.Null {
10801				atomic.AddUint32(&invalids, 1)
10802			}
10803		case "actors":
10804			field := field
10805			out.Concurrently(i, func() (res graphql.Marshaler) {
10806				defer func() {
10807					if r := recover(); r != nil {
10808						ec.Error(ctx, ec.Recover(ctx, r))
10809					}
10810				}()
10811				res = ec._Bug_actors(ctx, field, obj)
10812				if res == graphql.Null {
10813					atomic.AddUint32(&invalids, 1)
10814				}
10815				return res
10816			})
10817		case "participants":
10818			field := field
10819			out.Concurrently(i, func() (res graphql.Marshaler) {
10820				defer func() {
10821					if r := recover(); r != nil {
10822						ec.Error(ctx, ec.Recover(ctx, r))
10823					}
10824				}()
10825				res = ec._Bug_participants(ctx, field, obj)
10826				if res == graphql.Null {
10827					atomic.AddUint32(&invalids, 1)
10828				}
10829				return res
10830			})
10831		case "comments":
10832			field := field
10833			out.Concurrently(i, func() (res graphql.Marshaler) {
10834				defer func() {
10835					if r := recover(); r != nil {
10836						ec.Error(ctx, ec.Recover(ctx, r))
10837					}
10838				}()
10839				res = ec._Bug_comments(ctx, field, obj)
10840				if res == graphql.Null {
10841					atomic.AddUint32(&invalids, 1)
10842				}
10843				return res
10844			})
10845		case "timeline":
10846			field := field
10847			out.Concurrently(i, func() (res graphql.Marshaler) {
10848				defer func() {
10849					if r := recover(); r != nil {
10850						ec.Error(ctx, ec.Recover(ctx, r))
10851					}
10852				}()
10853				res = ec._Bug_timeline(ctx, field, obj)
10854				if res == graphql.Null {
10855					atomic.AddUint32(&invalids, 1)
10856				}
10857				return res
10858			})
10859		case "operations":
10860			field := field
10861			out.Concurrently(i, func() (res graphql.Marshaler) {
10862				defer func() {
10863					if r := recover(); r != nil {
10864						ec.Error(ctx, ec.Recover(ctx, r))
10865					}
10866				}()
10867				res = ec._Bug_operations(ctx, field, obj)
10868				if res == graphql.Null {
10869					atomic.AddUint32(&invalids, 1)
10870				}
10871				return res
10872			})
10873		default:
10874			panic("unknown field " + strconv.Quote(field.Name))
10875		}
10876	}
10877	out.Dispatch()
10878	if invalids > 0 {
10879		return graphql.Null
10880	}
10881	return out
10882}
10883
10884var bugConnectionImplementors = []string{"BugConnection"}
10885
10886func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10887	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10888
10889	out := graphql.NewFieldSet(fields)
10890	var invalids uint32
10891	for i, field := range fields {
10892		switch field.Name {
10893		case "__typename":
10894			out.Values[i] = graphql.MarshalString("BugConnection")
10895		case "edges":
10896			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10897			if out.Values[i] == graphql.Null {
10898				invalids++
10899			}
10900		case "nodes":
10901			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10902			if out.Values[i] == graphql.Null {
10903				invalids++
10904			}
10905		case "pageInfo":
10906			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10907			if out.Values[i] == graphql.Null {
10908				invalids++
10909			}
10910		case "totalCount":
10911			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
10912			if out.Values[i] == graphql.Null {
10913				invalids++
10914			}
10915		default:
10916			panic("unknown field " + strconv.Quote(field.Name))
10917		}
10918	}
10919	out.Dispatch()
10920	if invalids > 0 {
10921		return graphql.Null
10922	}
10923	return out
10924}
10925
10926var bugEdgeImplementors = []string{"BugEdge"}
10927
10928func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
10929	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
10930
10931	out := graphql.NewFieldSet(fields)
10932	var invalids uint32
10933	for i, field := range fields {
10934		switch field.Name {
10935		case "__typename":
10936			out.Values[i] = graphql.MarshalString("BugEdge")
10937		case "cursor":
10938			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
10939			if out.Values[i] == graphql.Null {
10940				invalids++
10941			}
10942		case "node":
10943			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
10944			if out.Values[i] == graphql.Null {
10945				invalids++
10946			}
10947		default:
10948			panic("unknown field " + strconv.Quote(field.Name))
10949		}
10950	}
10951	out.Dispatch()
10952	if invalids > 0 {
10953		return graphql.Null
10954	}
10955	return out
10956}
10957
10958var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
10959
10960func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
10961	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
10962
10963	out := graphql.NewFieldSet(fields)
10964	var invalids uint32
10965	for i, field := range fields {
10966		switch field.Name {
10967		case "__typename":
10968			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
10969		case "clientMutationId":
10970			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
10971		case "bug":
10972			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
10973			if out.Values[i] == graphql.Null {
10974				invalids++
10975			}
10976		case "operation":
10977			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
10978			if out.Values[i] == graphql.Null {
10979				invalids++
10980			}
10981		case "results":
10982			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
10983			if out.Values[i] == graphql.Null {
10984				invalids++
10985			}
10986		default:
10987			panic("unknown field " + strconv.Quote(field.Name))
10988		}
10989	}
10990	out.Dispatch()
10991	if invalids > 0 {
10992		return graphql.Null
10993	}
10994	return out
10995}
10996
10997var closeBugPayloadImplementors = []string{"CloseBugPayload"}
10998
10999func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11000	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11001
11002	out := graphql.NewFieldSet(fields)
11003	var invalids uint32
11004	for i, field := range fields {
11005		switch field.Name {
11006		case "__typename":
11007			out.Values[i] = graphql.MarshalString("CloseBugPayload")
11008		case "clientMutationId":
11009			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11010		case "bug":
11011			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11012			if out.Values[i] == graphql.Null {
11013				invalids++
11014			}
11015		case "operation":
11016			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11017			if out.Values[i] == graphql.Null {
11018				invalids++
11019			}
11020		default:
11021			panic("unknown field " + strconv.Quote(field.Name))
11022		}
11023	}
11024	out.Dispatch()
11025	if invalids > 0 {
11026		return graphql.Null
11027	}
11028	return out
11029}
11030
11031var colorImplementors = []string{"Color"}
11032
11033func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11034	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11035
11036	out := graphql.NewFieldSet(fields)
11037	var invalids uint32
11038	for i, field := range fields {
11039		switch field.Name {
11040		case "__typename":
11041			out.Values[i] = graphql.MarshalString("Color")
11042		case "R":
11043			field := field
11044			out.Concurrently(i, func() (res graphql.Marshaler) {
11045				defer func() {
11046					if r := recover(); r != nil {
11047						ec.Error(ctx, ec.Recover(ctx, r))
11048					}
11049				}()
11050				res = ec._Color_R(ctx, field, obj)
11051				if res == graphql.Null {
11052					atomic.AddUint32(&invalids, 1)
11053				}
11054				return res
11055			})
11056		case "G":
11057			field := field
11058			out.Concurrently(i, func() (res graphql.Marshaler) {
11059				defer func() {
11060					if r := recover(); r != nil {
11061						ec.Error(ctx, ec.Recover(ctx, r))
11062					}
11063				}()
11064				res = ec._Color_G(ctx, field, obj)
11065				if res == graphql.Null {
11066					atomic.AddUint32(&invalids, 1)
11067				}
11068				return res
11069			})
11070		case "B":
11071			field := field
11072			out.Concurrently(i, func() (res graphql.Marshaler) {
11073				defer func() {
11074					if r := recover(); r != nil {
11075						ec.Error(ctx, ec.Recover(ctx, r))
11076					}
11077				}()
11078				res = ec._Color_B(ctx, field, obj)
11079				if res == graphql.Null {
11080					atomic.AddUint32(&invalids, 1)
11081				}
11082				return res
11083			})
11084		default:
11085			panic("unknown field " + strconv.Quote(field.Name))
11086		}
11087	}
11088	out.Dispatch()
11089	if invalids > 0 {
11090		return graphql.Null
11091	}
11092	return out
11093}
11094
11095var commentImplementors = []string{"Comment", "Authored"}
11096
11097func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11098	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11099
11100	out := graphql.NewFieldSet(fields)
11101	var invalids uint32
11102	for i, field := range fields {
11103		switch field.Name {
11104		case "__typename":
11105			out.Values[i] = graphql.MarshalString("Comment")
11106		case "author":
11107			field := field
11108			out.Concurrently(i, func() (res graphql.Marshaler) {
11109				defer func() {
11110					if r := recover(); r != nil {
11111						ec.Error(ctx, ec.Recover(ctx, r))
11112					}
11113				}()
11114				res = ec._Comment_author(ctx, field, obj)
11115				if res == graphql.Null {
11116					atomic.AddUint32(&invalids, 1)
11117				}
11118				return res
11119			})
11120		case "message":
11121			out.Values[i] = ec._Comment_message(ctx, field, obj)
11122			if out.Values[i] == graphql.Null {
11123				atomic.AddUint32(&invalids, 1)
11124			}
11125		case "files":
11126			out.Values[i] = ec._Comment_files(ctx, field, obj)
11127			if out.Values[i] == graphql.Null {
11128				atomic.AddUint32(&invalids, 1)
11129			}
11130		default:
11131			panic("unknown field " + strconv.Quote(field.Name))
11132		}
11133	}
11134	out.Dispatch()
11135	if invalids > 0 {
11136		return graphql.Null
11137	}
11138	return out
11139}
11140
11141var commentConnectionImplementors = []string{"CommentConnection"}
11142
11143func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11144	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11145
11146	out := graphql.NewFieldSet(fields)
11147	var invalids uint32
11148	for i, field := range fields {
11149		switch field.Name {
11150		case "__typename":
11151			out.Values[i] = graphql.MarshalString("CommentConnection")
11152		case "edges":
11153			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11154			if out.Values[i] == graphql.Null {
11155				invalids++
11156			}
11157		case "nodes":
11158			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11159			if out.Values[i] == graphql.Null {
11160				invalids++
11161			}
11162		case "pageInfo":
11163			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11164			if out.Values[i] == graphql.Null {
11165				invalids++
11166			}
11167		case "totalCount":
11168			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11169			if out.Values[i] == graphql.Null {
11170				invalids++
11171			}
11172		default:
11173			panic("unknown field " + strconv.Quote(field.Name))
11174		}
11175	}
11176	out.Dispatch()
11177	if invalids > 0 {
11178		return graphql.Null
11179	}
11180	return out
11181}
11182
11183var commentEdgeImplementors = []string{"CommentEdge"}
11184
11185func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11186	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11187
11188	out := graphql.NewFieldSet(fields)
11189	var invalids uint32
11190	for i, field := range fields {
11191		switch field.Name {
11192		case "__typename":
11193			out.Values[i] = graphql.MarshalString("CommentEdge")
11194		case "cursor":
11195			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11196			if out.Values[i] == graphql.Null {
11197				invalids++
11198			}
11199		case "node":
11200			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11201			if out.Values[i] == graphql.Null {
11202				invalids++
11203			}
11204		default:
11205			panic("unknown field " + strconv.Quote(field.Name))
11206		}
11207	}
11208	out.Dispatch()
11209	if invalids > 0 {
11210		return graphql.Null
11211	}
11212	return out
11213}
11214
11215var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11216
11217func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11218	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11219
11220	out := graphql.NewFieldSet(fields)
11221	var invalids uint32
11222	for i, field := range fields {
11223		switch field.Name {
11224		case "__typename":
11225			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11226		case "message":
11227			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11228			if out.Values[i] == graphql.Null {
11229				atomic.AddUint32(&invalids, 1)
11230			}
11231		case "date":
11232			field := field
11233			out.Concurrently(i, func() (res graphql.Marshaler) {
11234				defer func() {
11235					if r := recover(); r != nil {
11236						ec.Error(ctx, ec.Recover(ctx, r))
11237					}
11238				}()
11239				res = ec._CommentHistoryStep_date(ctx, field, obj)
11240				if res == graphql.Null {
11241					atomic.AddUint32(&invalids, 1)
11242				}
11243				return res
11244			})
11245		default:
11246			panic("unknown field " + strconv.Quote(field.Name))
11247		}
11248	}
11249	out.Dispatch()
11250	if invalids > 0 {
11251		return graphql.Null
11252	}
11253	return out
11254}
11255
11256var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11257
11258func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11259	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11260
11261	out := graphql.NewFieldSet(fields)
11262	var invalids uint32
11263	for i, field := range fields {
11264		switch field.Name {
11265		case "__typename":
11266			out.Values[i] = graphql.MarshalString("CreateOperation")
11267		case "id":
11268			field := field
11269			out.Concurrently(i, func() (res graphql.Marshaler) {
11270				defer func() {
11271					if r := recover(); r != nil {
11272						ec.Error(ctx, ec.Recover(ctx, r))
11273					}
11274				}()
11275				res = ec._CreateOperation_id(ctx, field, obj)
11276				if res == graphql.Null {
11277					atomic.AddUint32(&invalids, 1)
11278				}
11279				return res
11280			})
11281		case "author":
11282			field := field
11283			out.Concurrently(i, func() (res graphql.Marshaler) {
11284				defer func() {
11285					if r := recover(); r != nil {
11286						ec.Error(ctx, ec.Recover(ctx, r))
11287					}
11288				}()
11289				res = ec._CreateOperation_author(ctx, field, obj)
11290				if res == graphql.Null {
11291					atomic.AddUint32(&invalids, 1)
11292				}
11293				return res
11294			})
11295		case "date":
11296			field := field
11297			out.Concurrently(i, func() (res graphql.Marshaler) {
11298				defer func() {
11299					if r := recover(); r != nil {
11300						ec.Error(ctx, ec.Recover(ctx, r))
11301					}
11302				}()
11303				res = ec._CreateOperation_date(ctx, field, obj)
11304				if res == graphql.Null {
11305					atomic.AddUint32(&invalids, 1)
11306				}
11307				return res
11308			})
11309		case "title":
11310			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11311			if out.Values[i] == graphql.Null {
11312				atomic.AddUint32(&invalids, 1)
11313			}
11314		case "message":
11315			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11316			if out.Values[i] == graphql.Null {
11317				atomic.AddUint32(&invalids, 1)
11318			}
11319		case "files":
11320			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11321			if out.Values[i] == graphql.Null {
11322				atomic.AddUint32(&invalids, 1)
11323			}
11324		default:
11325			panic("unknown field " + strconv.Quote(field.Name))
11326		}
11327	}
11328	out.Dispatch()
11329	if invalids > 0 {
11330		return graphql.Null
11331	}
11332	return out
11333}
11334
11335var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11336
11337func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11338	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11339
11340	out := graphql.NewFieldSet(fields)
11341	var invalids uint32
11342	for i, field := range fields {
11343		switch field.Name {
11344		case "__typename":
11345			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11346		case "id":
11347			field := field
11348			out.Concurrently(i, func() (res graphql.Marshaler) {
11349				defer func() {
11350					if r := recover(); r != nil {
11351						ec.Error(ctx, ec.Recover(ctx, r))
11352					}
11353				}()
11354				res = ec._CreateTimelineItem_id(ctx, field, obj)
11355				if res == graphql.Null {
11356					atomic.AddUint32(&invalids, 1)
11357				}
11358				return res
11359			})
11360		case "author":
11361			field := field
11362			out.Concurrently(i, func() (res graphql.Marshaler) {
11363				defer func() {
11364					if r := recover(); r != nil {
11365						ec.Error(ctx, ec.Recover(ctx, r))
11366					}
11367				}()
11368				res = ec._CreateTimelineItem_author(ctx, field, obj)
11369				if res == graphql.Null {
11370					atomic.AddUint32(&invalids, 1)
11371				}
11372				return res
11373			})
11374		case "message":
11375			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11376			if out.Values[i] == graphql.Null {
11377				atomic.AddUint32(&invalids, 1)
11378			}
11379		case "messageIsEmpty":
11380			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11381			if out.Values[i] == graphql.Null {
11382				atomic.AddUint32(&invalids, 1)
11383			}
11384		case "files":
11385			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11386			if out.Values[i] == graphql.Null {
11387				atomic.AddUint32(&invalids, 1)
11388			}
11389		case "createdAt":
11390			field := field
11391			out.Concurrently(i, func() (res graphql.Marshaler) {
11392				defer func() {
11393					if r := recover(); r != nil {
11394						ec.Error(ctx, ec.Recover(ctx, r))
11395					}
11396				}()
11397				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11398				if res == graphql.Null {
11399					atomic.AddUint32(&invalids, 1)
11400				}
11401				return res
11402			})
11403		case "lastEdit":
11404			field := field
11405			out.Concurrently(i, func() (res graphql.Marshaler) {
11406				defer func() {
11407					if r := recover(); r != nil {
11408						ec.Error(ctx, ec.Recover(ctx, r))
11409					}
11410				}()
11411				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11412				if res == graphql.Null {
11413					atomic.AddUint32(&invalids, 1)
11414				}
11415				return res
11416			})
11417		case "edited":
11418			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11419			if out.Values[i] == graphql.Null {
11420				atomic.AddUint32(&invalids, 1)
11421			}
11422		case "history":
11423			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11424			if out.Values[i] == graphql.Null {
11425				atomic.AddUint32(&invalids, 1)
11426			}
11427		default:
11428			panic("unknown field " + strconv.Quote(field.Name))
11429		}
11430	}
11431	out.Dispatch()
11432	if invalids > 0 {
11433		return graphql.Null
11434	}
11435	return out
11436}
11437
11438var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11439
11440func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11441	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11442
11443	out := graphql.NewFieldSet(fields)
11444	var invalids uint32
11445	for i, field := range fields {
11446		switch field.Name {
11447		case "__typename":
11448			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11449		case "id":
11450			field := field
11451			out.Concurrently(i, func() (res graphql.Marshaler) {
11452				defer func() {
11453					if r := recover(); r != nil {
11454						ec.Error(ctx, ec.Recover(ctx, r))
11455					}
11456				}()
11457				res = ec._EditCommentOperation_id(ctx, field, obj)
11458				if res == graphql.Null {
11459					atomic.AddUint32(&invalids, 1)
11460				}
11461				return res
11462			})
11463		case "author":
11464			field := field
11465			out.Concurrently(i, func() (res graphql.Marshaler) {
11466				defer func() {
11467					if r := recover(); r != nil {
11468						ec.Error(ctx, ec.Recover(ctx, r))
11469					}
11470				}()
11471				res = ec._EditCommentOperation_author(ctx, field, obj)
11472				if res == graphql.Null {
11473					atomic.AddUint32(&invalids, 1)
11474				}
11475				return res
11476			})
11477		case "date":
11478			field := field
11479			out.Concurrently(i, func() (res graphql.Marshaler) {
11480				defer func() {
11481					if r := recover(); r != nil {
11482						ec.Error(ctx, ec.Recover(ctx, r))
11483					}
11484				}()
11485				res = ec._EditCommentOperation_date(ctx, field, obj)
11486				if res == graphql.Null {
11487					atomic.AddUint32(&invalids, 1)
11488				}
11489				return res
11490			})
11491		case "target":
11492			field := field
11493			out.Concurrently(i, func() (res graphql.Marshaler) {
11494				defer func() {
11495					if r := recover(); r != nil {
11496						ec.Error(ctx, ec.Recover(ctx, r))
11497					}
11498				}()
11499				res = ec._EditCommentOperation_target(ctx, field, obj)
11500				if res == graphql.Null {
11501					atomic.AddUint32(&invalids, 1)
11502				}
11503				return res
11504			})
11505		case "message":
11506			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11507			if out.Values[i] == graphql.Null {
11508				atomic.AddUint32(&invalids, 1)
11509			}
11510		case "files":
11511			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11512			if out.Values[i] == graphql.Null {
11513				atomic.AddUint32(&invalids, 1)
11514			}
11515		default:
11516			panic("unknown field " + strconv.Quote(field.Name))
11517		}
11518	}
11519	out.Dispatch()
11520	if invalids > 0 {
11521		return graphql.Null
11522	}
11523	return out
11524}
11525
11526var editCommentPayloadImplementors = []string{"EditCommentPayload"}
11527
11528func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
11529	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
11530
11531	out := graphql.NewFieldSet(fields)
11532	var invalids uint32
11533	for i, field := range fields {
11534		switch field.Name {
11535		case "__typename":
11536			out.Values[i] = graphql.MarshalString("EditCommentPayload")
11537		case "clientMutationId":
11538			out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
11539		case "bug":
11540			out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
11541			if out.Values[i] == graphql.Null {
11542				invalids++
11543			}
11544		case "operation":
11545			out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
11546			if out.Values[i] == graphql.Null {
11547				invalids++
11548			}
11549		default:
11550			panic("unknown field " + strconv.Quote(field.Name))
11551		}
11552	}
11553	out.Dispatch()
11554	if invalids > 0 {
11555		return graphql.Null
11556	}
11557	return out
11558}
11559
11560var identityImplementors = []string{"Identity"}
11561
11562func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11563	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11564
11565	out := graphql.NewFieldSet(fields)
11566	var invalids uint32
11567	for i, field := range fields {
11568		switch field.Name {
11569		case "__typename":
11570			out.Values[i] = graphql.MarshalString("Identity")
11571		case "id":
11572			field := field
11573			out.Concurrently(i, func() (res graphql.Marshaler) {
11574				defer func() {
11575					if r := recover(); r != nil {
11576						ec.Error(ctx, ec.Recover(ctx, r))
11577					}
11578				}()
11579				res = ec._Identity_id(ctx, field, obj)
11580				if res == graphql.Null {
11581					atomic.AddUint32(&invalids, 1)
11582				}
11583				return res
11584			})
11585		case "humanId":
11586			field := field
11587			out.Concurrently(i, func() (res graphql.Marshaler) {
11588				defer func() {
11589					if r := recover(); r != nil {
11590						ec.Error(ctx, ec.Recover(ctx, r))
11591					}
11592				}()
11593				res = ec._Identity_humanId(ctx, field, obj)
11594				if res == graphql.Null {
11595					atomic.AddUint32(&invalids, 1)
11596				}
11597				return res
11598			})
11599		case "name":
11600			out.Values[i] = ec._Identity_name(ctx, field, obj)
11601		case "email":
11602			out.Values[i] = ec._Identity_email(ctx, field, obj)
11603		case "login":
11604			out.Values[i] = ec._Identity_login(ctx, field, obj)
11605		case "displayName":
11606			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11607			if out.Values[i] == graphql.Null {
11608				atomic.AddUint32(&invalids, 1)
11609			}
11610		case "avatarUrl":
11611			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11612		case "isProtected":
11613			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11614			if out.Values[i] == graphql.Null {
11615				atomic.AddUint32(&invalids, 1)
11616			}
11617		default:
11618			panic("unknown field " + strconv.Quote(field.Name))
11619		}
11620	}
11621	out.Dispatch()
11622	if invalids > 0 {
11623		return graphql.Null
11624	}
11625	return out
11626}
11627
11628var identityConnectionImplementors = []string{"IdentityConnection"}
11629
11630func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11631	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11632
11633	out := graphql.NewFieldSet(fields)
11634	var invalids uint32
11635	for i, field := range fields {
11636		switch field.Name {
11637		case "__typename":
11638			out.Values[i] = graphql.MarshalString("IdentityConnection")
11639		case "edges":
11640			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11641			if out.Values[i] == graphql.Null {
11642				invalids++
11643			}
11644		case "nodes":
11645			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11646			if out.Values[i] == graphql.Null {
11647				invalids++
11648			}
11649		case "pageInfo":
11650			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11651			if out.Values[i] == graphql.Null {
11652				invalids++
11653			}
11654		case "totalCount":
11655			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11656			if out.Values[i] == graphql.Null {
11657				invalids++
11658			}
11659		default:
11660			panic("unknown field " + strconv.Quote(field.Name))
11661		}
11662	}
11663	out.Dispatch()
11664	if invalids > 0 {
11665		return graphql.Null
11666	}
11667	return out
11668}
11669
11670var identityEdgeImplementors = []string{"IdentityEdge"}
11671
11672func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11673	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11674
11675	out := graphql.NewFieldSet(fields)
11676	var invalids uint32
11677	for i, field := range fields {
11678		switch field.Name {
11679		case "__typename":
11680			out.Values[i] = graphql.MarshalString("IdentityEdge")
11681		case "cursor":
11682			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11683			if out.Values[i] == graphql.Null {
11684				invalids++
11685			}
11686		case "node":
11687			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11688			if out.Values[i] == graphql.Null {
11689				invalids++
11690			}
11691		default:
11692			panic("unknown field " + strconv.Quote(field.Name))
11693		}
11694	}
11695	out.Dispatch()
11696	if invalids > 0 {
11697		return graphql.Null
11698	}
11699	return out
11700}
11701
11702var labelImplementors = []string{"Label"}
11703
11704func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11705	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11706
11707	out := graphql.NewFieldSet(fields)
11708	var invalids uint32
11709	for i, field := range fields {
11710		switch field.Name {
11711		case "__typename":
11712			out.Values[i] = graphql.MarshalString("Label")
11713		case "name":
11714			field := field
11715			out.Concurrently(i, func() (res graphql.Marshaler) {
11716				defer func() {
11717					if r := recover(); r != nil {
11718						ec.Error(ctx, ec.Recover(ctx, r))
11719					}
11720				}()
11721				res = ec._Label_name(ctx, field, obj)
11722				if res == graphql.Null {
11723					atomic.AddUint32(&invalids, 1)
11724				}
11725				return res
11726			})
11727		case "color":
11728			field := field
11729			out.Concurrently(i, func() (res graphql.Marshaler) {
11730				defer func() {
11731					if r := recover(); r != nil {
11732						ec.Error(ctx, ec.Recover(ctx, r))
11733					}
11734				}()
11735				res = ec._Label_color(ctx, field, obj)
11736				if res == graphql.Null {
11737					atomic.AddUint32(&invalids, 1)
11738				}
11739				return res
11740			})
11741		default:
11742			panic("unknown field " + strconv.Quote(field.Name))
11743		}
11744	}
11745	out.Dispatch()
11746	if invalids > 0 {
11747		return graphql.Null
11748	}
11749	return out
11750}
11751
11752var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11753
11754func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11755	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11756
11757	out := graphql.NewFieldSet(fields)
11758	var invalids uint32
11759	for i, field := range fields {
11760		switch field.Name {
11761		case "__typename":
11762			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11763		case "id":
11764			field := field
11765			out.Concurrently(i, func() (res graphql.Marshaler) {
11766				defer func() {
11767					if r := recover(); r != nil {
11768						ec.Error(ctx, ec.Recover(ctx, r))
11769					}
11770				}()
11771				res = ec._LabelChangeOperation_id(ctx, field, obj)
11772				if res == graphql.Null {
11773					atomic.AddUint32(&invalids, 1)
11774				}
11775				return res
11776			})
11777		case "author":
11778			field := field
11779			out.Concurrently(i, func() (res graphql.Marshaler) {
11780				defer func() {
11781					if r := recover(); r != nil {
11782						ec.Error(ctx, ec.Recover(ctx, r))
11783					}
11784				}()
11785				res = ec._LabelChangeOperation_author(ctx, field, obj)
11786				if res == graphql.Null {
11787					atomic.AddUint32(&invalids, 1)
11788				}
11789				return res
11790			})
11791		case "date":
11792			field := field
11793			out.Concurrently(i, func() (res graphql.Marshaler) {
11794				defer func() {
11795					if r := recover(); r != nil {
11796						ec.Error(ctx, ec.Recover(ctx, r))
11797					}
11798				}()
11799				res = ec._LabelChangeOperation_date(ctx, field, obj)
11800				if res == graphql.Null {
11801					atomic.AddUint32(&invalids, 1)
11802				}
11803				return res
11804			})
11805		case "added":
11806			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11807			if out.Values[i] == graphql.Null {
11808				atomic.AddUint32(&invalids, 1)
11809			}
11810		case "removed":
11811			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11812			if out.Values[i] == graphql.Null {
11813				atomic.AddUint32(&invalids, 1)
11814			}
11815		default:
11816			panic("unknown field " + strconv.Quote(field.Name))
11817		}
11818	}
11819	out.Dispatch()
11820	if invalids > 0 {
11821		return graphql.Null
11822	}
11823	return out
11824}
11825
11826var labelChangeResultImplementors = []string{"LabelChangeResult"}
11827
11828func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11829	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11830
11831	out := graphql.NewFieldSet(fields)
11832	var invalids uint32
11833	for i, field := range fields {
11834		switch field.Name {
11835		case "__typename":
11836			out.Values[i] = graphql.MarshalString("LabelChangeResult")
11837		case "label":
11838			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11839			if out.Values[i] == graphql.Null {
11840				atomic.AddUint32(&invalids, 1)
11841			}
11842		case "status":
11843			field := field
11844			out.Concurrently(i, func() (res graphql.Marshaler) {
11845				defer func() {
11846					if r := recover(); r != nil {
11847						ec.Error(ctx, ec.Recover(ctx, r))
11848					}
11849				}()
11850				res = ec._LabelChangeResult_status(ctx, field, obj)
11851				if res == graphql.Null {
11852					atomic.AddUint32(&invalids, 1)
11853				}
11854				return res
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 labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11868
11869func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11870	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
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("LabelChangeTimelineItem")
11878		case "id":
11879			field := field
11880			out.Concurrently(i, func() (res graphql.Marshaler) {
11881				defer func() {
11882					if r := recover(); r != nil {
11883						ec.Error(ctx, ec.Recover(ctx, r))
11884					}
11885				}()
11886				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11887				if res == graphql.Null {
11888					atomic.AddUint32(&invalids, 1)
11889				}
11890				return res
11891			})
11892		case "author":
11893			field := field
11894			out.Concurrently(i, func() (res graphql.Marshaler) {
11895				defer func() {
11896					if r := recover(); r != nil {
11897						ec.Error(ctx, ec.Recover(ctx, r))
11898					}
11899				}()
11900				res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
11901				if res == graphql.Null {
11902					atomic.AddUint32(&invalids, 1)
11903				}
11904				return res
11905			})
11906		case "date":
11907			field := field
11908			out.Concurrently(i, func() (res graphql.Marshaler) {
11909				defer func() {
11910					if r := recover(); r != nil {
11911						ec.Error(ctx, ec.Recover(ctx, r))
11912					}
11913				}()
11914				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
11915				if res == graphql.Null {
11916					atomic.AddUint32(&invalids, 1)
11917				}
11918				return res
11919			})
11920		case "added":
11921			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
11922			if out.Values[i] == graphql.Null {
11923				atomic.AddUint32(&invalids, 1)
11924			}
11925		case "removed":
11926			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
11927			if out.Values[i] == graphql.Null {
11928				atomic.AddUint32(&invalids, 1)
11929			}
11930		default:
11931			panic("unknown field " + strconv.Quote(field.Name))
11932		}
11933	}
11934	out.Dispatch()
11935	if invalids > 0 {
11936		return graphql.Null
11937	}
11938	return out
11939}
11940
11941var labelConnectionImplementors = []string{"LabelConnection"}
11942
11943func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
11944	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
11945
11946	out := graphql.NewFieldSet(fields)
11947	var invalids uint32
11948	for i, field := range fields {
11949		switch field.Name {
11950		case "__typename":
11951			out.Values[i] = graphql.MarshalString("LabelConnection")
11952		case "edges":
11953			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
11954			if out.Values[i] == graphql.Null {
11955				invalids++
11956			}
11957		case "nodes":
11958			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
11959			if out.Values[i] == graphql.Null {
11960				invalids++
11961			}
11962		case "pageInfo":
11963			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
11964			if out.Values[i] == graphql.Null {
11965				invalids++
11966			}
11967		case "totalCount":
11968			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
11969			if out.Values[i] == graphql.Null {
11970				invalids++
11971			}
11972		default:
11973			panic("unknown field " + strconv.Quote(field.Name))
11974		}
11975	}
11976	out.Dispatch()
11977	if invalids > 0 {
11978		return graphql.Null
11979	}
11980	return out
11981}
11982
11983var labelEdgeImplementors = []string{"LabelEdge"}
11984
11985func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
11986	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
11987
11988	out := graphql.NewFieldSet(fields)
11989	var invalids uint32
11990	for i, field := range fields {
11991		switch field.Name {
11992		case "__typename":
11993			out.Values[i] = graphql.MarshalString("LabelEdge")
11994		case "cursor":
11995			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
11996			if out.Values[i] == graphql.Null {
11997				invalids++
11998			}
11999		case "node":
12000			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12001			if out.Values[i] == graphql.Null {
12002				invalids++
12003			}
12004		default:
12005			panic("unknown field " + strconv.Quote(field.Name))
12006		}
12007	}
12008	out.Dispatch()
12009	if invalids > 0 {
12010		return graphql.Null
12011	}
12012	return out
12013}
12014
12015var mutationImplementors = []string{"Mutation"}
12016
12017func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12018	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12019
12020	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12021		Object: "Mutation",
12022	})
12023
12024	out := graphql.NewFieldSet(fields)
12025	var invalids uint32
12026	for i, field := range fields {
12027		switch field.Name {
12028		case "__typename":
12029			out.Values[i] = graphql.MarshalString("Mutation")
12030		case "newBug":
12031			out.Values[i] = ec._Mutation_newBug(ctx, field)
12032			if out.Values[i] == graphql.Null {
12033				invalids++
12034			}
12035		case "addComment":
12036			out.Values[i] = ec._Mutation_addComment(ctx, field)
12037			if out.Values[i] == graphql.Null {
12038				invalids++
12039			}
12040		case "editComment":
12041			out.Values[i] = ec._Mutation_editComment(ctx, field)
12042			if out.Values[i] == graphql.Null {
12043				invalids++
12044			}
12045		case "changeLabels":
12046			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12047			if out.Values[i] == graphql.Null {
12048				invalids++
12049			}
12050		case "openBug":
12051			out.Values[i] = ec._Mutation_openBug(ctx, field)
12052			if out.Values[i] == graphql.Null {
12053				invalids++
12054			}
12055		case "closeBug":
12056			out.Values[i] = ec._Mutation_closeBug(ctx, field)
12057			if out.Values[i] == graphql.Null {
12058				invalids++
12059			}
12060		case "setTitle":
12061			out.Values[i] = ec._Mutation_setTitle(ctx, field)
12062			if out.Values[i] == graphql.Null {
12063				invalids++
12064			}
12065		default:
12066			panic("unknown field " + strconv.Quote(field.Name))
12067		}
12068	}
12069	out.Dispatch()
12070	if invalids > 0 {
12071		return graphql.Null
12072	}
12073	return out
12074}
12075
12076var newBugPayloadImplementors = []string{"NewBugPayload"}
12077
12078func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12079	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12080
12081	out := graphql.NewFieldSet(fields)
12082	var invalids uint32
12083	for i, field := range fields {
12084		switch field.Name {
12085		case "__typename":
12086			out.Values[i] = graphql.MarshalString("NewBugPayload")
12087		case "clientMutationId":
12088			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12089		case "bug":
12090			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12091			if out.Values[i] == graphql.Null {
12092				invalids++
12093			}
12094		case "operation":
12095			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12096			if out.Values[i] == graphql.Null {
12097				invalids++
12098			}
12099		default:
12100			panic("unknown field " + strconv.Quote(field.Name))
12101		}
12102	}
12103	out.Dispatch()
12104	if invalids > 0 {
12105		return graphql.Null
12106	}
12107	return out
12108}
12109
12110var openBugPayloadImplementors = []string{"OpenBugPayload"}
12111
12112func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12113	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
12114
12115	out := graphql.NewFieldSet(fields)
12116	var invalids uint32
12117	for i, field := range fields {
12118		switch field.Name {
12119		case "__typename":
12120			out.Values[i] = graphql.MarshalString("OpenBugPayload")
12121		case "clientMutationId":
12122			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12123		case "bug":
12124			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12125			if out.Values[i] == graphql.Null {
12126				invalids++
12127			}
12128		case "operation":
12129			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12130			if out.Values[i] == graphql.Null {
12131				invalids++
12132			}
12133		default:
12134			panic("unknown field " + strconv.Quote(field.Name))
12135		}
12136	}
12137	out.Dispatch()
12138	if invalids > 0 {
12139		return graphql.Null
12140	}
12141	return out
12142}
12143
12144var operationConnectionImplementors = []string{"OperationConnection"}
12145
12146func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12147	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12148
12149	out := graphql.NewFieldSet(fields)
12150	var invalids uint32
12151	for i, field := range fields {
12152		switch field.Name {
12153		case "__typename":
12154			out.Values[i] = graphql.MarshalString("OperationConnection")
12155		case "edges":
12156			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12157			if out.Values[i] == graphql.Null {
12158				invalids++
12159			}
12160		case "nodes":
12161			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12162			if out.Values[i] == graphql.Null {
12163				invalids++
12164			}
12165		case "pageInfo":
12166			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12167			if out.Values[i] == graphql.Null {
12168				invalids++
12169			}
12170		case "totalCount":
12171			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12172			if out.Values[i] == graphql.Null {
12173				invalids++
12174			}
12175		default:
12176			panic("unknown field " + strconv.Quote(field.Name))
12177		}
12178	}
12179	out.Dispatch()
12180	if invalids > 0 {
12181		return graphql.Null
12182	}
12183	return out
12184}
12185
12186var operationEdgeImplementors = []string{"OperationEdge"}
12187
12188func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12189	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12190
12191	out := graphql.NewFieldSet(fields)
12192	var invalids uint32
12193	for i, field := range fields {
12194		switch field.Name {
12195		case "__typename":
12196			out.Values[i] = graphql.MarshalString("OperationEdge")
12197		case "cursor":
12198			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12199			if out.Values[i] == graphql.Null {
12200				invalids++
12201			}
12202		case "node":
12203			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12204			if out.Values[i] == graphql.Null {
12205				invalids++
12206			}
12207		default:
12208			panic("unknown field " + strconv.Quote(field.Name))
12209		}
12210	}
12211	out.Dispatch()
12212	if invalids > 0 {
12213		return graphql.Null
12214	}
12215	return out
12216}
12217
12218var pageInfoImplementors = []string{"PageInfo"}
12219
12220func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12221	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12222
12223	out := graphql.NewFieldSet(fields)
12224	var invalids uint32
12225	for i, field := range fields {
12226		switch field.Name {
12227		case "__typename":
12228			out.Values[i] = graphql.MarshalString("PageInfo")
12229		case "hasNextPage":
12230			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12231			if out.Values[i] == graphql.Null {
12232				invalids++
12233			}
12234		case "hasPreviousPage":
12235			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12236			if out.Values[i] == graphql.Null {
12237				invalids++
12238			}
12239		case "startCursor":
12240			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12241			if out.Values[i] == graphql.Null {
12242				invalids++
12243			}
12244		case "endCursor":
12245			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12246			if out.Values[i] == graphql.Null {
12247				invalids++
12248			}
12249		default:
12250			panic("unknown field " + strconv.Quote(field.Name))
12251		}
12252	}
12253	out.Dispatch()
12254	if invalids > 0 {
12255		return graphql.Null
12256	}
12257	return out
12258}
12259
12260var queryImplementors = []string{"Query"}
12261
12262func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12263	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12264
12265	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12266		Object: "Query",
12267	})
12268
12269	out := graphql.NewFieldSet(fields)
12270	var invalids uint32
12271	for i, field := range fields {
12272		switch field.Name {
12273		case "__typename":
12274			out.Values[i] = graphql.MarshalString("Query")
12275		case "repository":
12276			field := field
12277			out.Concurrently(i, func() (res graphql.Marshaler) {
12278				defer func() {
12279					if r := recover(); r != nil {
12280						ec.Error(ctx, ec.Recover(ctx, r))
12281					}
12282				}()
12283				res = ec._Query_repository(ctx, field)
12284				return res
12285			})
12286		case "__type":
12287			out.Values[i] = ec._Query___type(ctx, field)
12288		case "__schema":
12289			out.Values[i] = ec._Query___schema(ctx, field)
12290		default:
12291			panic("unknown field " + strconv.Quote(field.Name))
12292		}
12293	}
12294	out.Dispatch()
12295	if invalids > 0 {
12296		return graphql.Null
12297	}
12298	return out
12299}
12300
12301var repositoryImplementors = []string{"Repository"}
12302
12303func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12304	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12305
12306	out := graphql.NewFieldSet(fields)
12307	var invalids uint32
12308	for i, field := range fields {
12309		switch field.Name {
12310		case "__typename":
12311			out.Values[i] = graphql.MarshalString("Repository")
12312		case "name":
12313			field := field
12314			out.Concurrently(i, func() (res graphql.Marshaler) {
12315				defer func() {
12316					if r := recover(); r != nil {
12317						ec.Error(ctx, ec.Recover(ctx, r))
12318					}
12319				}()
12320				res = ec._Repository_name(ctx, field, obj)
12321				return res
12322			})
12323		case "allBugs":
12324			field := field
12325			out.Concurrently(i, func() (res graphql.Marshaler) {
12326				defer func() {
12327					if r := recover(); r != nil {
12328						ec.Error(ctx, ec.Recover(ctx, r))
12329					}
12330				}()
12331				res = ec._Repository_allBugs(ctx, field, obj)
12332				if res == graphql.Null {
12333					atomic.AddUint32(&invalids, 1)
12334				}
12335				return res
12336			})
12337		case "bug":
12338			field := field
12339			out.Concurrently(i, func() (res graphql.Marshaler) {
12340				defer func() {
12341					if r := recover(); r != nil {
12342						ec.Error(ctx, ec.Recover(ctx, r))
12343					}
12344				}()
12345				res = ec._Repository_bug(ctx, field, obj)
12346				return res
12347			})
12348		case "allIdentities":
12349			field := field
12350			out.Concurrently(i, func() (res graphql.Marshaler) {
12351				defer func() {
12352					if r := recover(); r != nil {
12353						ec.Error(ctx, ec.Recover(ctx, r))
12354					}
12355				}()
12356				res = ec._Repository_allIdentities(ctx, field, obj)
12357				if res == graphql.Null {
12358					atomic.AddUint32(&invalids, 1)
12359				}
12360				return res
12361			})
12362		case "identity":
12363			field := field
12364			out.Concurrently(i, func() (res graphql.Marshaler) {
12365				defer func() {
12366					if r := recover(); r != nil {
12367						ec.Error(ctx, ec.Recover(ctx, r))
12368					}
12369				}()
12370				res = ec._Repository_identity(ctx, field, obj)
12371				return res
12372			})
12373		case "userIdentity":
12374			field := field
12375			out.Concurrently(i, func() (res graphql.Marshaler) {
12376				defer func() {
12377					if r := recover(); r != nil {
12378						ec.Error(ctx, ec.Recover(ctx, r))
12379					}
12380				}()
12381				res = ec._Repository_userIdentity(ctx, field, obj)
12382				return res
12383			})
12384		case "validLabels":
12385			field := field
12386			out.Concurrently(i, func() (res graphql.Marshaler) {
12387				defer func() {
12388					if r := recover(); r != nil {
12389						ec.Error(ctx, ec.Recover(ctx, r))
12390					}
12391				}()
12392				res = ec._Repository_validLabels(ctx, field, obj)
12393				if res == graphql.Null {
12394					atomic.AddUint32(&invalids, 1)
12395				}
12396				return res
12397			})
12398		default:
12399			panic("unknown field " + strconv.Quote(field.Name))
12400		}
12401	}
12402	out.Dispatch()
12403	if invalids > 0 {
12404		return graphql.Null
12405	}
12406	return out
12407}
12408
12409var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12410
12411func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12412	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12413
12414	out := graphql.NewFieldSet(fields)
12415	var invalids uint32
12416	for i, field := range fields {
12417		switch field.Name {
12418		case "__typename":
12419			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12420		case "id":
12421			field := field
12422			out.Concurrently(i, func() (res graphql.Marshaler) {
12423				defer func() {
12424					if r := recover(); r != nil {
12425						ec.Error(ctx, ec.Recover(ctx, r))
12426					}
12427				}()
12428				res = ec._SetStatusOperation_id(ctx, field, obj)
12429				if res == graphql.Null {
12430					atomic.AddUint32(&invalids, 1)
12431				}
12432				return res
12433			})
12434		case "author":
12435			field := field
12436			out.Concurrently(i, func() (res graphql.Marshaler) {
12437				defer func() {
12438					if r := recover(); r != nil {
12439						ec.Error(ctx, ec.Recover(ctx, r))
12440					}
12441				}()
12442				res = ec._SetStatusOperation_author(ctx, field, obj)
12443				if res == graphql.Null {
12444					atomic.AddUint32(&invalids, 1)
12445				}
12446				return res
12447			})
12448		case "date":
12449			field := field
12450			out.Concurrently(i, func() (res graphql.Marshaler) {
12451				defer func() {
12452					if r := recover(); r != nil {
12453						ec.Error(ctx, ec.Recover(ctx, r))
12454					}
12455				}()
12456				res = ec._SetStatusOperation_date(ctx, field, obj)
12457				if res == graphql.Null {
12458					atomic.AddUint32(&invalids, 1)
12459				}
12460				return res
12461			})
12462		case "status":
12463			field := field
12464			out.Concurrently(i, func() (res graphql.Marshaler) {
12465				defer func() {
12466					if r := recover(); r != nil {
12467						ec.Error(ctx, ec.Recover(ctx, r))
12468					}
12469				}()
12470				res = ec._SetStatusOperation_status(ctx, field, obj)
12471				if res == graphql.Null {
12472					atomic.AddUint32(&invalids, 1)
12473				}
12474				return res
12475			})
12476		default:
12477			panic("unknown field " + strconv.Quote(field.Name))
12478		}
12479	}
12480	out.Dispatch()
12481	if invalids > 0 {
12482		return graphql.Null
12483	}
12484	return out
12485}
12486
12487var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12488
12489func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12490	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12491
12492	out := graphql.NewFieldSet(fields)
12493	var invalids uint32
12494	for i, field := range fields {
12495		switch field.Name {
12496		case "__typename":
12497			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12498		case "id":
12499			field := field
12500			out.Concurrently(i, func() (res graphql.Marshaler) {
12501				defer func() {
12502					if r := recover(); r != nil {
12503						ec.Error(ctx, ec.Recover(ctx, r))
12504					}
12505				}()
12506				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12507				if res == graphql.Null {
12508					atomic.AddUint32(&invalids, 1)
12509				}
12510				return res
12511			})
12512		case "author":
12513			field := field
12514			out.Concurrently(i, func() (res graphql.Marshaler) {
12515				defer func() {
12516					if r := recover(); r != nil {
12517						ec.Error(ctx, ec.Recover(ctx, r))
12518					}
12519				}()
12520				res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12521				if res == graphql.Null {
12522					atomic.AddUint32(&invalids, 1)
12523				}
12524				return res
12525			})
12526		case "date":
12527			field := field
12528			out.Concurrently(i, func() (res graphql.Marshaler) {
12529				defer func() {
12530					if r := recover(); r != nil {
12531						ec.Error(ctx, ec.Recover(ctx, r))
12532					}
12533				}()
12534				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12535				if res == graphql.Null {
12536					atomic.AddUint32(&invalids, 1)
12537				}
12538				return res
12539			})
12540		case "status":
12541			field := field
12542			out.Concurrently(i, func() (res graphql.Marshaler) {
12543				defer func() {
12544					if r := recover(); r != nil {
12545						ec.Error(ctx, ec.Recover(ctx, r))
12546					}
12547				}()
12548				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12549				if res == graphql.Null {
12550					atomic.AddUint32(&invalids, 1)
12551				}
12552				return res
12553			})
12554		default:
12555			panic("unknown field " + strconv.Quote(field.Name))
12556		}
12557	}
12558	out.Dispatch()
12559	if invalids > 0 {
12560		return graphql.Null
12561	}
12562	return out
12563}
12564
12565var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12566
12567func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12568	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12569
12570	out := graphql.NewFieldSet(fields)
12571	var invalids uint32
12572	for i, field := range fields {
12573		switch field.Name {
12574		case "__typename":
12575			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12576		case "id":
12577			field := field
12578			out.Concurrently(i, func() (res graphql.Marshaler) {
12579				defer func() {
12580					if r := recover(); r != nil {
12581						ec.Error(ctx, ec.Recover(ctx, r))
12582					}
12583				}()
12584				res = ec._SetTitleOperation_id(ctx, field, obj)
12585				if res == graphql.Null {
12586					atomic.AddUint32(&invalids, 1)
12587				}
12588				return res
12589			})
12590		case "author":
12591			field := field
12592			out.Concurrently(i, func() (res graphql.Marshaler) {
12593				defer func() {
12594					if r := recover(); r != nil {
12595						ec.Error(ctx, ec.Recover(ctx, r))
12596					}
12597				}()
12598				res = ec._SetTitleOperation_author(ctx, field, obj)
12599				if res == graphql.Null {
12600					atomic.AddUint32(&invalids, 1)
12601				}
12602				return res
12603			})
12604		case "date":
12605			field := field
12606			out.Concurrently(i, func() (res graphql.Marshaler) {
12607				defer func() {
12608					if r := recover(); r != nil {
12609						ec.Error(ctx, ec.Recover(ctx, r))
12610					}
12611				}()
12612				res = ec._SetTitleOperation_date(ctx, field, obj)
12613				if res == graphql.Null {
12614					atomic.AddUint32(&invalids, 1)
12615				}
12616				return res
12617			})
12618		case "title":
12619			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12620			if out.Values[i] == graphql.Null {
12621				atomic.AddUint32(&invalids, 1)
12622			}
12623		case "was":
12624			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12625			if out.Values[i] == graphql.Null {
12626				atomic.AddUint32(&invalids, 1)
12627			}
12628		default:
12629			panic("unknown field " + strconv.Quote(field.Name))
12630		}
12631	}
12632	out.Dispatch()
12633	if invalids > 0 {
12634		return graphql.Null
12635	}
12636	return out
12637}
12638
12639var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12640
12641func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12642	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12643
12644	out := graphql.NewFieldSet(fields)
12645	var invalids uint32
12646	for i, field := range fields {
12647		switch field.Name {
12648		case "__typename":
12649			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12650		case "clientMutationId":
12651			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12652		case "bug":
12653			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12654			if out.Values[i] == graphql.Null {
12655				invalids++
12656			}
12657		case "operation":
12658			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12659			if out.Values[i] == graphql.Null {
12660				invalids++
12661			}
12662		default:
12663			panic("unknown field " + strconv.Quote(field.Name))
12664		}
12665	}
12666	out.Dispatch()
12667	if invalids > 0 {
12668		return graphql.Null
12669	}
12670	return out
12671}
12672
12673var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12674
12675func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12676	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12677
12678	out := graphql.NewFieldSet(fields)
12679	var invalids uint32
12680	for i, field := range fields {
12681		switch field.Name {
12682		case "__typename":
12683			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12684		case "id":
12685			field := field
12686			out.Concurrently(i, func() (res graphql.Marshaler) {
12687				defer func() {
12688					if r := recover(); r != nil {
12689						ec.Error(ctx, ec.Recover(ctx, r))
12690					}
12691				}()
12692				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12693				if res == graphql.Null {
12694					atomic.AddUint32(&invalids, 1)
12695				}
12696				return res
12697			})
12698		case "author":
12699			field := field
12700			out.Concurrently(i, func() (res graphql.Marshaler) {
12701				defer func() {
12702					if r := recover(); r != nil {
12703						ec.Error(ctx, ec.Recover(ctx, r))
12704					}
12705				}()
12706				res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12707				if res == graphql.Null {
12708					atomic.AddUint32(&invalids, 1)
12709				}
12710				return res
12711			})
12712		case "date":
12713			field := field
12714			out.Concurrently(i, func() (res graphql.Marshaler) {
12715				defer func() {
12716					if r := recover(); r != nil {
12717						ec.Error(ctx, ec.Recover(ctx, r))
12718					}
12719				}()
12720				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12721				if res == graphql.Null {
12722					atomic.AddUint32(&invalids, 1)
12723				}
12724				return res
12725			})
12726		case "title":
12727			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12728			if out.Values[i] == graphql.Null {
12729				atomic.AddUint32(&invalids, 1)
12730			}
12731		case "was":
12732			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12733			if out.Values[i] == graphql.Null {
12734				atomic.AddUint32(&invalids, 1)
12735			}
12736		default:
12737			panic("unknown field " + strconv.Quote(field.Name))
12738		}
12739	}
12740	out.Dispatch()
12741	if invalids > 0 {
12742		return graphql.Null
12743	}
12744	return out
12745}
12746
12747var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12748
12749func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12750	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12751
12752	out := graphql.NewFieldSet(fields)
12753	var invalids uint32
12754	for i, field := range fields {
12755		switch field.Name {
12756		case "__typename":
12757			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12758		case "edges":
12759			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12760			if out.Values[i] == graphql.Null {
12761				invalids++
12762			}
12763		case "nodes":
12764			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12765			if out.Values[i] == graphql.Null {
12766				invalids++
12767			}
12768		case "pageInfo":
12769			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12770			if out.Values[i] == graphql.Null {
12771				invalids++
12772			}
12773		case "totalCount":
12774			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12775			if out.Values[i] == graphql.Null {
12776				invalids++
12777			}
12778		default:
12779			panic("unknown field " + strconv.Quote(field.Name))
12780		}
12781	}
12782	out.Dispatch()
12783	if invalids > 0 {
12784		return graphql.Null
12785	}
12786	return out
12787}
12788
12789var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12790
12791func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12792	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12793
12794	out := graphql.NewFieldSet(fields)
12795	var invalids uint32
12796	for i, field := range fields {
12797		switch field.Name {
12798		case "__typename":
12799			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12800		case "cursor":
12801			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12802			if out.Values[i] == graphql.Null {
12803				invalids++
12804			}
12805		case "node":
12806			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12807			if out.Values[i] == graphql.Null {
12808				invalids++
12809			}
12810		default:
12811			panic("unknown field " + strconv.Quote(field.Name))
12812		}
12813	}
12814	out.Dispatch()
12815	if invalids > 0 {
12816		return graphql.Null
12817	}
12818	return out
12819}
12820
12821var __DirectiveImplementors = []string{"__Directive"}
12822
12823func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12824	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12825
12826	out := graphql.NewFieldSet(fields)
12827	var invalids uint32
12828	for i, field := range fields {
12829		switch field.Name {
12830		case "__typename":
12831			out.Values[i] = graphql.MarshalString("__Directive")
12832		case "name":
12833			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12834			if out.Values[i] == graphql.Null {
12835				invalids++
12836			}
12837		case "description":
12838			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12839		case "locations":
12840			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12841			if out.Values[i] == graphql.Null {
12842				invalids++
12843			}
12844		case "args":
12845			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12846			if out.Values[i] == graphql.Null {
12847				invalids++
12848			}
12849		default:
12850			panic("unknown field " + strconv.Quote(field.Name))
12851		}
12852	}
12853	out.Dispatch()
12854	if invalids > 0 {
12855		return graphql.Null
12856	}
12857	return out
12858}
12859
12860var __EnumValueImplementors = []string{"__EnumValue"}
12861
12862func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12863	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12864
12865	out := graphql.NewFieldSet(fields)
12866	var invalids uint32
12867	for i, field := range fields {
12868		switch field.Name {
12869		case "__typename":
12870			out.Values[i] = graphql.MarshalString("__EnumValue")
12871		case "name":
12872			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12873			if out.Values[i] == graphql.Null {
12874				invalids++
12875			}
12876		case "description":
12877			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12878		case "isDeprecated":
12879			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12880			if out.Values[i] == graphql.Null {
12881				invalids++
12882			}
12883		case "deprecationReason":
12884			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12885		default:
12886			panic("unknown field " + strconv.Quote(field.Name))
12887		}
12888	}
12889	out.Dispatch()
12890	if invalids > 0 {
12891		return graphql.Null
12892	}
12893	return out
12894}
12895
12896var __FieldImplementors = []string{"__Field"}
12897
12898func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12899	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
12900
12901	out := graphql.NewFieldSet(fields)
12902	var invalids uint32
12903	for i, field := range fields {
12904		switch field.Name {
12905		case "__typename":
12906			out.Values[i] = graphql.MarshalString("__Field")
12907		case "name":
12908			out.Values[i] = ec.___Field_name(ctx, field, obj)
12909			if out.Values[i] == graphql.Null {
12910				invalids++
12911			}
12912		case "description":
12913			out.Values[i] = ec.___Field_description(ctx, field, obj)
12914		case "args":
12915			out.Values[i] = ec.___Field_args(ctx, field, obj)
12916			if out.Values[i] == graphql.Null {
12917				invalids++
12918			}
12919		case "type":
12920			out.Values[i] = ec.___Field_type(ctx, field, obj)
12921			if out.Values[i] == graphql.Null {
12922				invalids++
12923			}
12924		case "isDeprecated":
12925			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
12926			if out.Values[i] == graphql.Null {
12927				invalids++
12928			}
12929		case "deprecationReason":
12930			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
12931		default:
12932			panic("unknown field " + strconv.Quote(field.Name))
12933		}
12934	}
12935	out.Dispatch()
12936	if invalids > 0 {
12937		return graphql.Null
12938	}
12939	return out
12940}
12941
12942var __InputValueImplementors = []string{"__InputValue"}
12943
12944func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
12945	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
12946
12947	out := graphql.NewFieldSet(fields)
12948	var invalids uint32
12949	for i, field := range fields {
12950		switch field.Name {
12951		case "__typename":
12952			out.Values[i] = graphql.MarshalString("__InputValue")
12953		case "name":
12954			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
12955			if out.Values[i] == graphql.Null {
12956				invalids++
12957			}
12958		case "description":
12959			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
12960		case "type":
12961			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
12962			if out.Values[i] == graphql.Null {
12963				invalids++
12964			}
12965		case "defaultValue":
12966			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
12967		default:
12968			panic("unknown field " + strconv.Quote(field.Name))
12969		}
12970	}
12971	out.Dispatch()
12972	if invalids > 0 {
12973		return graphql.Null
12974	}
12975	return out
12976}
12977
12978var __SchemaImplementors = []string{"__Schema"}
12979
12980func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
12981	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
12982
12983	out := graphql.NewFieldSet(fields)
12984	var invalids uint32
12985	for i, field := range fields {
12986		switch field.Name {
12987		case "__typename":
12988			out.Values[i] = graphql.MarshalString("__Schema")
12989		case "types":
12990			out.Values[i] = ec.___Schema_types(ctx, field, obj)
12991			if out.Values[i] == graphql.Null {
12992				invalids++
12993			}
12994		case "queryType":
12995			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
12996			if out.Values[i] == graphql.Null {
12997				invalids++
12998			}
12999		case "mutationType":
13000			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13001		case "subscriptionType":
13002			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13003		case "directives":
13004			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13005			if out.Values[i] == graphql.Null {
13006				invalids++
13007			}
13008		default:
13009			panic("unknown field " + strconv.Quote(field.Name))
13010		}
13011	}
13012	out.Dispatch()
13013	if invalids > 0 {
13014		return graphql.Null
13015	}
13016	return out
13017}
13018
13019var __TypeImplementors = []string{"__Type"}
13020
13021func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13022	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13023
13024	out := graphql.NewFieldSet(fields)
13025	var invalids uint32
13026	for i, field := range fields {
13027		switch field.Name {
13028		case "__typename":
13029			out.Values[i] = graphql.MarshalString("__Type")
13030		case "kind":
13031			out.Values[i] = ec.___Type_kind(ctx, field, obj)
13032			if out.Values[i] == graphql.Null {
13033				invalids++
13034			}
13035		case "name":
13036			out.Values[i] = ec.___Type_name(ctx, field, obj)
13037		case "description":
13038			out.Values[i] = ec.___Type_description(ctx, field, obj)
13039		case "fields":
13040			out.Values[i] = ec.___Type_fields(ctx, field, obj)
13041		case "interfaces":
13042			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13043		case "possibleTypes":
13044			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13045		case "enumValues":
13046			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13047		case "inputFields":
13048			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13049		case "ofType":
13050			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13051		default:
13052			panic("unknown field " + strconv.Quote(field.Name))
13053		}
13054	}
13055	out.Dispatch()
13056	if invalids > 0 {
13057		return graphql.Null
13058	}
13059	return out
13060}
13061
13062// endregion **************************** object.gotpl ****************************
13063
13064// region    ***************************** type.gotpl *****************************
13065
13066func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13067	return ec.unmarshalInputAddCommentInput(ctx, v)
13068}
13069
13070func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13071	return ec._AddCommentOperation(ctx, sel, &v)
13072}
13073
13074func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13075	if v == nil {
13076		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13077			ec.Errorf(ctx, "must not be null")
13078		}
13079		return graphql.Null
13080	}
13081	return ec._AddCommentOperation(ctx, sel, v)
13082}
13083
13084func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13085	return ec._AddCommentPayload(ctx, sel, &v)
13086}
13087
13088func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13089	if v == nil {
13090		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13091			ec.Errorf(ctx, "must not be null")
13092		}
13093		return graphql.Null
13094	}
13095	return ec._AddCommentPayload(ctx, sel, v)
13096}
13097
13098func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13099	return graphql.UnmarshalBoolean(v)
13100}
13101
13102func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13103	res := graphql.MarshalBoolean(v)
13104	if res == graphql.Null {
13105		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13106			ec.Errorf(ctx, "must not be null")
13107		}
13108	}
13109	return res
13110}
13111
13112func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13113	if v == nil {
13114		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13115			ec.Errorf(ctx, "must not be null")
13116		}
13117		return graphql.Null
13118	}
13119	return ec._Bug(ctx, sel, v)
13120}
13121
13122func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13123	ret := make(graphql.Array, len(v))
13124	var wg sync.WaitGroup
13125	isLen1 := len(v) == 1
13126	if !isLen1 {
13127		wg.Add(len(v))
13128	}
13129	for i := range v {
13130		i := i
13131		fc := &graphql.FieldContext{
13132			Index:  &i,
13133			Result: &v[i],
13134		}
13135		ctx := graphql.WithFieldContext(ctx, fc)
13136		f := func(i int) {
13137			defer func() {
13138				if r := recover(); r != nil {
13139					ec.Error(ctx, ec.Recover(ctx, r))
13140					ret = nil
13141				}
13142			}()
13143			if !isLen1 {
13144				defer wg.Done()
13145			}
13146			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13147		}
13148		if isLen1 {
13149			f(i)
13150		} else {
13151			go f(i)
13152		}
13153
13154	}
13155	wg.Wait()
13156	return ret
13157}
13158
13159func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13160	return ec._BugConnection(ctx, sel, &v)
13161}
13162
13163func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13164	if v == nil {
13165		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13166			ec.Errorf(ctx, "must not be null")
13167		}
13168		return graphql.Null
13169	}
13170	return ec._BugConnection(ctx, sel, v)
13171}
13172
13173func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13174	return ec._BugEdge(ctx, sel, &v)
13175}
13176
13177func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13178	ret := make(graphql.Array, len(v))
13179	var wg sync.WaitGroup
13180	isLen1 := len(v) == 1
13181	if !isLen1 {
13182		wg.Add(len(v))
13183	}
13184	for i := range v {
13185		i := i
13186		fc := &graphql.FieldContext{
13187			Index:  &i,
13188			Result: &v[i],
13189		}
13190		ctx := graphql.WithFieldContext(ctx, fc)
13191		f := func(i int) {
13192			defer func() {
13193				if r := recover(); r != nil {
13194					ec.Error(ctx, ec.Recover(ctx, r))
13195					ret = nil
13196				}
13197			}()
13198			if !isLen1 {
13199				defer wg.Done()
13200			}
13201			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13202		}
13203		if isLen1 {
13204			f(i)
13205		} else {
13206			go f(i)
13207		}
13208
13209	}
13210	wg.Wait()
13211	return ret
13212}
13213
13214func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13215	if v == nil {
13216		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13217			ec.Errorf(ctx, "must not be null")
13218		}
13219		return graphql.Null
13220	}
13221	return ec._BugEdge(ctx, sel, v)
13222}
13223
13224func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13225	return ec._ChangeLabelPayload(ctx, sel, &v)
13226}
13227
13228func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13229	if v == nil {
13230		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13231			ec.Errorf(ctx, "must not be null")
13232		}
13233		return graphql.Null
13234	}
13235	return ec._ChangeLabelPayload(ctx, sel, v)
13236}
13237
13238func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13239	return ec.unmarshalInputCloseBugInput(ctx, v)
13240}
13241
13242func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13243	return ec._CloseBugPayload(ctx, sel, &v)
13244}
13245
13246func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13247	if v == nil {
13248		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13249			ec.Errorf(ctx, "must not be null")
13250		}
13251		return graphql.Null
13252	}
13253	return ec._CloseBugPayload(ctx, sel, v)
13254}
13255
13256func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13257	return ec._Color(ctx, sel, &v)
13258}
13259
13260func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13261	if v == nil {
13262		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13263			ec.Errorf(ctx, "must not be null")
13264		}
13265		return graphql.Null
13266	}
13267	return ec._Color(ctx, sel, v)
13268}
13269
13270func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13271	return ec._Comment(ctx, sel, &v)
13272}
13273
13274func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13275	ret := make(graphql.Array, len(v))
13276	var wg sync.WaitGroup
13277	isLen1 := len(v) == 1
13278	if !isLen1 {
13279		wg.Add(len(v))
13280	}
13281	for i := range v {
13282		i := i
13283		fc := &graphql.FieldContext{
13284			Index:  &i,
13285			Result: &v[i],
13286		}
13287		ctx := graphql.WithFieldContext(ctx, fc)
13288		f := func(i int) {
13289			defer func() {
13290				if r := recover(); r != nil {
13291					ec.Error(ctx, ec.Recover(ctx, r))
13292					ret = nil
13293				}
13294			}()
13295			if !isLen1 {
13296				defer wg.Done()
13297			}
13298			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13299		}
13300		if isLen1 {
13301			f(i)
13302		} else {
13303			go f(i)
13304		}
13305
13306	}
13307	wg.Wait()
13308	return ret
13309}
13310
13311func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13312	if v == nil {
13313		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13314			ec.Errorf(ctx, "must not be null")
13315		}
13316		return graphql.Null
13317	}
13318	return ec._Comment(ctx, sel, v)
13319}
13320
13321func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13322	return ec._CommentConnection(ctx, sel, &v)
13323}
13324
13325func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13326	if v == nil {
13327		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13328			ec.Errorf(ctx, "must not be null")
13329		}
13330		return graphql.Null
13331	}
13332	return ec._CommentConnection(ctx, sel, v)
13333}
13334
13335func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13336	return ec._CommentEdge(ctx, sel, &v)
13337}
13338
13339func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13340	ret := make(graphql.Array, len(v))
13341	var wg sync.WaitGroup
13342	isLen1 := len(v) == 1
13343	if !isLen1 {
13344		wg.Add(len(v))
13345	}
13346	for i := range v {
13347		i := i
13348		fc := &graphql.FieldContext{
13349			Index:  &i,
13350			Result: &v[i],
13351		}
13352		ctx := graphql.WithFieldContext(ctx, fc)
13353		f := func(i int) {
13354			defer func() {
13355				if r := recover(); r != nil {
13356					ec.Error(ctx, ec.Recover(ctx, r))
13357					ret = nil
13358				}
13359			}()
13360			if !isLen1 {
13361				defer wg.Done()
13362			}
13363			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13364		}
13365		if isLen1 {
13366			f(i)
13367		} else {
13368			go f(i)
13369		}
13370
13371	}
13372	wg.Wait()
13373	return ret
13374}
13375
13376func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13377	if v == nil {
13378		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13379			ec.Errorf(ctx, "must not be null")
13380		}
13381		return graphql.Null
13382	}
13383	return ec._CommentEdge(ctx, sel, v)
13384}
13385
13386func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13387	return ec._CommentHistoryStep(ctx, sel, &v)
13388}
13389
13390func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13391	ret := make(graphql.Array, len(v))
13392	var wg sync.WaitGroup
13393	isLen1 := len(v) == 1
13394	if !isLen1 {
13395		wg.Add(len(v))
13396	}
13397	for i := range v {
13398		i := i
13399		fc := &graphql.FieldContext{
13400			Index:  &i,
13401			Result: &v[i],
13402		}
13403		ctx := graphql.WithFieldContext(ctx, fc)
13404		f := func(i int) {
13405			defer func() {
13406				if r := recover(); r != nil {
13407					ec.Error(ctx, ec.Recover(ctx, r))
13408					ret = nil
13409				}
13410			}()
13411			if !isLen1 {
13412				defer wg.Done()
13413			}
13414			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13415		}
13416		if isLen1 {
13417			f(i)
13418		} else {
13419			go f(i)
13420		}
13421
13422	}
13423	wg.Wait()
13424	return ret
13425}
13426
13427func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13428	return ec._CreateOperation(ctx, sel, &v)
13429}
13430
13431func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13432	if v == nil {
13433		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13434			ec.Errorf(ctx, "must not be null")
13435		}
13436		return graphql.Null
13437	}
13438	return ec._CreateOperation(ctx, sel, v)
13439}
13440
13441func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
13442	return ec.unmarshalInputEditCommentInput(ctx, v)
13443}
13444
13445func (ec *executionContext) marshalNEditCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.EditCommentOperation) graphql.Marshaler {
13446	return ec._EditCommentOperation(ctx, sel, &v)
13447}
13448
13449func (ec *executionContext) marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐEditCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.EditCommentOperation) graphql.Marshaler {
13450	if v == nil {
13451		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13452			ec.Errorf(ctx, "must not be null")
13453		}
13454		return graphql.Null
13455	}
13456	return ec._EditCommentOperation(ctx, sel, v)
13457}
13458
13459func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
13460	return ec._EditCommentPayload(ctx, sel, &v)
13461}
13462
13463func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
13464	if v == nil {
13465		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13466			ec.Errorf(ctx, "must not be null")
13467		}
13468		return graphql.Null
13469	}
13470	return ec._EditCommentPayload(ctx, sel, v)
13471}
13472
13473func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, v interface{}) (repository.Hash, error) {
13474	var res repository.Hash
13475	return res, res.UnmarshalGQL(v)
13476}
13477
13478func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx context.Context, sel ast.SelectionSet, v repository.Hash) graphql.Marshaler {
13479	return v
13480}
13481
13482func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
13483	var vSlice []interface{}
13484	if v != nil {
13485		if tmp1, ok := v.([]interface{}); ok {
13486			vSlice = tmp1
13487		} else {
13488			vSlice = []interface{}{v}
13489		}
13490	}
13491	var err error
13492	res := make([]repository.Hash, len(vSlice))
13493	for i := range vSlice {
13494		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
13495		if err != nil {
13496			return nil, err
13497		}
13498	}
13499	return res, nil
13500}
13501
13502func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
13503	ret := make(graphql.Array, len(v))
13504	for i := range v {
13505		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
13506	}
13507
13508	return ret
13509}
13510
13511func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13512	if v == nil {
13513		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13514			ec.Errorf(ctx, "must not be null")
13515		}
13516		return graphql.Null
13517	}
13518	return ec._Identity(ctx, sel, v)
13519}
13520
13521func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) 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.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(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) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13559	return ec._IdentityConnection(ctx, sel, &v)
13560}
13561
13562func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13563	if v == nil {
13564		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13565			ec.Errorf(ctx, "must not be null")
13566		}
13567		return graphql.Null
13568	}
13569	return ec._IdentityConnection(ctx, sel, v)
13570}
13571
13572func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13573	return ec._IdentityEdge(ctx, sel, &v)
13574}
13575
13576func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13577	ret := make(graphql.Array, len(v))
13578	var wg sync.WaitGroup
13579	isLen1 := len(v) == 1
13580	if !isLen1 {
13581		wg.Add(len(v))
13582	}
13583	for i := range v {
13584		i := i
13585		fc := &graphql.FieldContext{
13586			Index:  &i,
13587			Result: &v[i],
13588		}
13589		ctx := graphql.WithFieldContext(ctx, fc)
13590		f := func(i int) {
13591			defer func() {
13592				if r := recover(); r != nil {
13593					ec.Error(ctx, ec.Recover(ctx, r))
13594					ret = nil
13595				}
13596			}()
13597			if !isLen1 {
13598				defer wg.Done()
13599			}
13600			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13601		}
13602		if isLen1 {
13603			f(i)
13604		} else {
13605			go f(i)
13606		}
13607
13608	}
13609	wg.Wait()
13610	return ret
13611}
13612
13613func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13614	if v == nil {
13615		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13616			ec.Errorf(ctx, "must not be null")
13617		}
13618		return graphql.Null
13619	}
13620	return ec._IdentityEdge(ctx, sel, v)
13621}
13622
13623func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13624	return graphql.UnmarshalInt(v)
13625}
13626
13627func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13628	res := graphql.MarshalInt(v)
13629	if res == graphql.Null {
13630		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13631			ec.Errorf(ctx, "must not be null")
13632		}
13633	}
13634	return res
13635}
13636
13637func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13638	return ec._Label(ctx, sel, &v)
13639}
13640
13641func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13642	ret := make(graphql.Array, len(v))
13643	var wg sync.WaitGroup
13644	isLen1 := len(v) == 1
13645	if !isLen1 {
13646		wg.Add(len(v))
13647	}
13648	for i := range v {
13649		i := i
13650		fc := &graphql.FieldContext{
13651			Index:  &i,
13652			Result: &v[i],
13653		}
13654		ctx := graphql.WithFieldContext(ctx, fc)
13655		f := func(i int) {
13656			defer func() {
13657				if r := recover(); r != nil {
13658					ec.Error(ctx, ec.Recover(ctx, r))
13659					ret = nil
13660				}
13661			}()
13662			if !isLen1 {
13663				defer wg.Done()
13664			}
13665			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13666		}
13667		if isLen1 {
13668			f(i)
13669		} else {
13670			go f(i)
13671		}
13672
13673	}
13674	wg.Wait()
13675	return ret
13676}
13677
13678func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13679	return ec._LabelChangeOperation(ctx, sel, &v)
13680}
13681
13682func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13683	if v == nil {
13684		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13685			ec.Errorf(ctx, "must not be null")
13686		}
13687		return graphql.Null
13688	}
13689	return ec._LabelChangeOperation(ctx, sel, v)
13690}
13691
13692func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13693	ret := make(graphql.Array, len(v))
13694	var wg sync.WaitGroup
13695	isLen1 := len(v) == 1
13696	if !isLen1 {
13697		wg.Add(len(v))
13698	}
13699	for i := range v {
13700		i := i
13701		fc := &graphql.FieldContext{
13702			Index:  &i,
13703			Result: &v[i],
13704		}
13705		ctx := graphql.WithFieldContext(ctx, fc)
13706		f := func(i int) {
13707			defer func() {
13708				if r := recover(); r != nil {
13709					ec.Error(ctx, ec.Recover(ctx, r))
13710					ret = nil
13711				}
13712			}()
13713			if !isLen1 {
13714				defer wg.Done()
13715			}
13716			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13717		}
13718		if isLen1 {
13719			f(i)
13720		} else {
13721			go f(i)
13722		}
13723
13724	}
13725	wg.Wait()
13726	return ret
13727}
13728
13729func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13730	var res models.LabelChangeStatus
13731	return res, res.UnmarshalGQL(v)
13732}
13733
13734func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13735	return v
13736}
13737
13738func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13739	return ec._LabelConnection(ctx, sel, &v)
13740}
13741
13742func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) graphql.Marshaler {
13743	if v == nil {
13744		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13745			ec.Errorf(ctx, "must not be null")
13746		}
13747		return graphql.Null
13748	}
13749	return ec._LabelConnection(ctx, sel, v)
13750}
13751
13752func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13753	return ec._LabelEdge(ctx, sel, &v)
13754}
13755
13756func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13757	ret := make(graphql.Array, len(v))
13758	var wg sync.WaitGroup
13759	isLen1 := len(v) == 1
13760	if !isLen1 {
13761		wg.Add(len(v))
13762	}
13763	for i := range v {
13764		i := i
13765		fc := &graphql.FieldContext{
13766			Index:  &i,
13767			Result: &v[i],
13768		}
13769		ctx := graphql.WithFieldContext(ctx, fc)
13770		f := func(i int) {
13771			defer func() {
13772				if r := recover(); r != nil {
13773					ec.Error(ctx, ec.Recover(ctx, r))
13774					ret = nil
13775				}
13776			}()
13777			if !isLen1 {
13778				defer wg.Done()
13779			}
13780			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13781		}
13782		if isLen1 {
13783			f(i)
13784		} else {
13785			go f(i)
13786		}
13787
13788	}
13789	wg.Wait()
13790	return ret
13791}
13792
13793func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13794	if v == nil {
13795		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13796			ec.Errorf(ctx, "must not be null")
13797		}
13798		return graphql.Null
13799	}
13800	return ec._LabelEdge(ctx, sel, v)
13801}
13802
13803func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13804	return ec.unmarshalInputNewBugInput(ctx, v)
13805}
13806
13807func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13808	return ec._NewBugPayload(ctx, sel, &v)
13809}
13810
13811func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13812	if v == nil {
13813		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13814			ec.Errorf(ctx, "must not be null")
13815		}
13816		return graphql.Null
13817	}
13818	return ec._NewBugPayload(ctx, sel, v)
13819}
13820
13821func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13822	return ec.unmarshalInputOpenBugInput(ctx, v)
13823}
13824
13825func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13826	return ec._OpenBugPayload(ctx, sel, &v)
13827}
13828
13829func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13830	if v == nil {
13831		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13832			ec.Errorf(ctx, "must not be null")
13833		}
13834		return graphql.Null
13835	}
13836	return ec._OpenBugPayload(ctx, sel, v)
13837}
13838
13839func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13840	if v == nil {
13841		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13842			ec.Errorf(ctx, "must not be null")
13843		}
13844		return graphql.Null
13845	}
13846	return ec._Operation(ctx, sel, v)
13847}
13848
13849func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13850	ret := make(graphql.Array, len(v))
13851	var wg sync.WaitGroup
13852	isLen1 := len(v) == 1
13853	if !isLen1 {
13854		wg.Add(len(v))
13855	}
13856	for i := range v {
13857		i := i
13858		fc := &graphql.FieldContext{
13859			Index:  &i,
13860			Result: &v[i],
13861		}
13862		ctx := graphql.WithFieldContext(ctx, fc)
13863		f := func(i int) {
13864			defer func() {
13865				if r := recover(); r != nil {
13866					ec.Error(ctx, ec.Recover(ctx, r))
13867					ret = nil
13868				}
13869			}()
13870			if !isLen1 {
13871				defer wg.Done()
13872			}
13873			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13874		}
13875		if isLen1 {
13876			f(i)
13877		} else {
13878			go f(i)
13879		}
13880
13881	}
13882	wg.Wait()
13883	return ret
13884}
13885
13886func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13887	return ec._OperationConnection(ctx, sel, &v)
13888}
13889
13890func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13891	if v == nil {
13892		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13893			ec.Errorf(ctx, "must not be null")
13894		}
13895		return graphql.Null
13896	}
13897	return ec._OperationConnection(ctx, sel, v)
13898}
13899
13900func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13901	return ec._OperationEdge(ctx, sel, &v)
13902}
13903
13904func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13905	ret := make(graphql.Array, len(v))
13906	var wg sync.WaitGroup
13907	isLen1 := len(v) == 1
13908	if !isLen1 {
13909		wg.Add(len(v))
13910	}
13911	for i := range v {
13912		i := i
13913		fc := &graphql.FieldContext{
13914			Index:  &i,
13915			Result: &v[i],
13916		}
13917		ctx := graphql.WithFieldContext(ctx, fc)
13918		f := func(i int) {
13919			defer func() {
13920				if r := recover(); r != nil {
13921					ec.Error(ctx, ec.Recover(ctx, r))
13922					ret = nil
13923				}
13924			}()
13925			if !isLen1 {
13926				defer wg.Done()
13927			}
13928			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13929		}
13930		if isLen1 {
13931			f(i)
13932		} else {
13933			go f(i)
13934		}
13935
13936	}
13937	wg.Wait()
13938	return ret
13939}
13940
13941func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
13942	if v == nil {
13943		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13944			ec.Errorf(ctx, "must not be null")
13945		}
13946		return graphql.Null
13947	}
13948	return ec._OperationEdge(ctx, sel, v)
13949}
13950
13951func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
13952	return ec._PageInfo(ctx, sel, &v)
13953}
13954
13955func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
13956	if v == nil {
13957		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13958			ec.Errorf(ctx, "must not be null")
13959		}
13960		return graphql.Null
13961	}
13962	return ec._PageInfo(ctx, sel, v)
13963}
13964
13965func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
13966	return ec._SetStatusOperation(ctx, sel, &v)
13967}
13968
13969func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
13970	if v == nil {
13971		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13972			ec.Errorf(ctx, "must not be null")
13973		}
13974		return graphql.Null
13975	}
13976	return ec._SetStatusOperation(ctx, sel, v)
13977}
13978
13979func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
13980	return ec.unmarshalInputSetTitleInput(ctx, v)
13981}
13982
13983func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
13984	return ec._SetTitleOperation(ctx, sel, &v)
13985}
13986
13987func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
13988	if v == nil {
13989		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13990			ec.Errorf(ctx, "must not be null")
13991		}
13992		return graphql.Null
13993	}
13994	return ec._SetTitleOperation(ctx, sel, v)
13995}
13996
13997func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
13998	return ec._SetTitlePayload(ctx, sel, &v)
13999}
14000
14001func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14002	if v == nil {
14003		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14004			ec.Errorf(ctx, "must not be null")
14005		}
14006		return graphql.Null
14007	}
14008	return ec._SetTitlePayload(ctx, sel, v)
14009}
14010
14011func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14012	var res models.Status
14013	return res, res.UnmarshalGQL(v)
14014}
14015
14016func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14017	return v
14018}
14019
14020func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14021	return graphql.UnmarshalString(v)
14022}
14023
14024func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14025	res := graphql.MarshalString(v)
14026	if res == graphql.Null {
14027		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14028			ec.Errorf(ctx, "must not be null")
14029		}
14030	}
14031	return res
14032}
14033
14034func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14035	return graphql.UnmarshalTime(v)
14036}
14037
14038func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14039	res := graphql.MarshalTime(v)
14040	if res == graphql.Null {
14041		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14042			ec.Errorf(ctx, "must not be null")
14043		}
14044	}
14045	return res
14046}
14047
14048func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14049	if v == nil {
14050		return nil, nil
14051	}
14052	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14053	return &res, err
14054}
14055
14056func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14057	if v == nil {
14058		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14059			ec.Errorf(ctx, "must not be null")
14060		}
14061		return graphql.Null
14062	}
14063	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14064}
14065
14066func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14067	if v == nil {
14068		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14069			ec.Errorf(ctx, "must not be null")
14070		}
14071		return graphql.Null
14072	}
14073	return ec._TimelineItem(ctx, sel, v)
14074}
14075
14076func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14077	ret := make(graphql.Array, len(v))
14078	var wg sync.WaitGroup
14079	isLen1 := len(v) == 1
14080	if !isLen1 {
14081		wg.Add(len(v))
14082	}
14083	for i := range v {
14084		i := i
14085		fc := &graphql.FieldContext{
14086			Index:  &i,
14087			Result: &v[i],
14088		}
14089		ctx := graphql.WithFieldContext(ctx, fc)
14090		f := func(i int) {
14091			defer func() {
14092				if r := recover(); r != nil {
14093					ec.Error(ctx, ec.Recover(ctx, r))
14094					ret = nil
14095				}
14096			}()
14097			if !isLen1 {
14098				defer wg.Done()
14099			}
14100			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14101		}
14102		if isLen1 {
14103			f(i)
14104		} else {
14105			go f(i)
14106		}
14107
14108	}
14109	wg.Wait()
14110	return ret
14111}
14112
14113func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14114	return ec._TimelineItemConnection(ctx, sel, &v)
14115}
14116
14117func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14118	if v == nil {
14119		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14120			ec.Errorf(ctx, "must not be null")
14121		}
14122		return graphql.Null
14123	}
14124	return ec._TimelineItemConnection(ctx, sel, v)
14125}
14126
14127func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14128	return ec._TimelineItemEdge(ctx, sel, &v)
14129}
14130
14131func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14132	ret := make(graphql.Array, len(v))
14133	var wg sync.WaitGroup
14134	isLen1 := len(v) == 1
14135	if !isLen1 {
14136		wg.Add(len(v))
14137	}
14138	for i := range v {
14139		i := i
14140		fc := &graphql.FieldContext{
14141			Index:  &i,
14142			Result: &v[i],
14143		}
14144		ctx := graphql.WithFieldContext(ctx, fc)
14145		f := func(i int) {
14146			defer func() {
14147				if r := recover(); r != nil {
14148					ec.Error(ctx, ec.Recover(ctx, r))
14149					ret = nil
14150				}
14151			}()
14152			if !isLen1 {
14153				defer wg.Done()
14154			}
14155			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14156		}
14157		if isLen1 {
14158			f(i)
14159		} else {
14160			go f(i)
14161		}
14162
14163	}
14164	wg.Wait()
14165	return ret
14166}
14167
14168func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14169	if v == nil {
14170		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14171			ec.Errorf(ctx, "must not be null")
14172		}
14173		return graphql.Null
14174	}
14175	return ec._TimelineItemEdge(ctx, sel, v)
14176}
14177
14178func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14179	return ec.___Directive(ctx, sel, &v)
14180}
14181
14182func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14183	ret := make(graphql.Array, len(v))
14184	var wg sync.WaitGroup
14185	isLen1 := len(v) == 1
14186	if !isLen1 {
14187		wg.Add(len(v))
14188	}
14189	for i := range v {
14190		i := i
14191		fc := &graphql.FieldContext{
14192			Index:  &i,
14193			Result: &v[i],
14194		}
14195		ctx := graphql.WithFieldContext(ctx, fc)
14196		f := func(i int) {
14197			defer func() {
14198				if r := recover(); r != nil {
14199					ec.Error(ctx, ec.Recover(ctx, r))
14200					ret = nil
14201				}
14202			}()
14203			if !isLen1 {
14204				defer wg.Done()
14205			}
14206			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14207		}
14208		if isLen1 {
14209			f(i)
14210		} else {
14211			go f(i)
14212		}
14213
14214	}
14215	wg.Wait()
14216	return ret
14217}
14218
14219func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14220	return graphql.UnmarshalString(v)
14221}
14222
14223func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14224	res := graphql.MarshalString(v)
14225	if res == graphql.Null {
14226		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14227			ec.Errorf(ctx, "must not be null")
14228		}
14229	}
14230	return res
14231}
14232
14233func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14234	var vSlice []interface{}
14235	if v != nil {
14236		if tmp1, ok := v.([]interface{}); ok {
14237			vSlice = tmp1
14238		} else {
14239			vSlice = []interface{}{v}
14240		}
14241	}
14242	var err error
14243	res := make([]string, len(vSlice))
14244	for i := range vSlice {
14245		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14246		if err != nil {
14247			return nil, err
14248		}
14249	}
14250	return res, nil
14251}
14252
14253func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14254	ret := make(graphql.Array, len(v))
14255	var wg sync.WaitGroup
14256	isLen1 := len(v) == 1
14257	if !isLen1 {
14258		wg.Add(len(v))
14259	}
14260	for i := range v {
14261		i := i
14262		fc := &graphql.FieldContext{
14263			Index:  &i,
14264			Result: &v[i],
14265		}
14266		ctx := graphql.WithFieldContext(ctx, fc)
14267		f := func(i int) {
14268			defer func() {
14269				if r := recover(); r != nil {
14270					ec.Error(ctx, ec.Recover(ctx, r))
14271					ret = nil
14272				}
14273			}()
14274			if !isLen1 {
14275				defer wg.Done()
14276			}
14277			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14278		}
14279		if isLen1 {
14280			f(i)
14281		} else {
14282			go f(i)
14283		}
14284
14285	}
14286	wg.Wait()
14287	return ret
14288}
14289
14290func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14291	return ec.___EnumValue(ctx, sel, &v)
14292}
14293
14294func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14295	return ec.___Field(ctx, sel, &v)
14296}
14297
14298func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14299	return ec.___InputValue(ctx, sel, &v)
14300}
14301
14302func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14303	ret := make(graphql.Array, len(v))
14304	var wg sync.WaitGroup
14305	isLen1 := len(v) == 1
14306	if !isLen1 {
14307		wg.Add(len(v))
14308	}
14309	for i := range v {
14310		i := i
14311		fc := &graphql.FieldContext{
14312			Index:  &i,
14313			Result: &v[i],
14314		}
14315		ctx := graphql.WithFieldContext(ctx, fc)
14316		f := func(i int) {
14317			defer func() {
14318				if r := recover(); r != nil {
14319					ec.Error(ctx, ec.Recover(ctx, r))
14320					ret = nil
14321				}
14322			}()
14323			if !isLen1 {
14324				defer wg.Done()
14325			}
14326			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14327		}
14328		if isLen1 {
14329			f(i)
14330		} else {
14331			go f(i)
14332		}
14333
14334	}
14335	wg.Wait()
14336	return ret
14337}
14338
14339func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14340	return ec.___Type(ctx, sel, &v)
14341}
14342
14343func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14344	ret := make(graphql.Array, len(v))
14345	var wg sync.WaitGroup
14346	isLen1 := len(v) == 1
14347	if !isLen1 {
14348		wg.Add(len(v))
14349	}
14350	for i := range v {
14351		i := i
14352		fc := &graphql.FieldContext{
14353			Index:  &i,
14354			Result: &v[i],
14355		}
14356		ctx := graphql.WithFieldContext(ctx, fc)
14357		f := func(i int) {
14358			defer func() {
14359				if r := recover(); r != nil {
14360					ec.Error(ctx, ec.Recover(ctx, r))
14361					ret = nil
14362				}
14363			}()
14364			if !isLen1 {
14365				defer wg.Done()
14366			}
14367			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14368		}
14369		if isLen1 {
14370			f(i)
14371		} else {
14372			go f(i)
14373		}
14374
14375	}
14376	wg.Wait()
14377	return ret
14378}
14379
14380func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14381	if v == nil {
14382		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14383			ec.Errorf(ctx, "must not be null")
14384		}
14385		return graphql.Null
14386	}
14387	return ec.___Type(ctx, sel, v)
14388}
14389
14390func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14391	return graphql.UnmarshalString(v)
14392}
14393
14394func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14395	res := graphql.MarshalString(v)
14396	if res == graphql.Null {
14397		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14398			ec.Errorf(ctx, "must not be null")
14399		}
14400	}
14401	return res
14402}
14403
14404func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14405	return graphql.UnmarshalBoolean(v)
14406}
14407
14408func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14409	return graphql.MarshalBoolean(v)
14410}
14411
14412func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14413	if v == nil {
14414		return nil, nil
14415	}
14416	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14417	return &res, err
14418}
14419
14420func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14421	if v == nil {
14422		return graphql.Null
14423	}
14424	return ec.marshalOBoolean2bool(ctx, sel, *v)
14425}
14426
14427func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14428	if v == nil {
14429		return graphql.Null
14430	}
14431	return ec._Bug(ctx, sel, v)
14432}
14433
14434func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14435	return ec.unmarshalInputChangeLabelInput(ctx, v)
14436}
14437
14438func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14439	if v == nil {
14440		return nil, nil
14441	}
14442	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14443	return &res, err
14444}
14445
14446func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, v interface{}) ([]repository.Hash, error) {
14447	var vSlice []interface{}
14448	if v != nil {
14449		if tmp1, ok := v.([]interface{}); ok {
14450			vSlice = tmp1
14451		} else {
14452			vSlice = []interface{}{v}
14453		}
14454	}
14455	var err error
14456	res := make([]repository.Hash, len(vSlice))
14457	for i := range vSlice {
14458		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, vSlice[i])
14459		if err != nil {
14460			return nil, err
14461		}
14462	}
14463	return res, nil
14464}
14465
14466func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.Hash) graphql.Marshaler {
14467	if v == nil {
14468		return graphql.Null
14469	}
14470	ret := make(graphql.Array, len(v))
14471	for i := range v {
14472		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHash(ctx, sel, v[i])
14473	}
14474
14475	return ret
14476}
14477
14478func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14479	if v == nil {
14480		return graphql.Null
14481	}
14482	return ec._Identity(ctx, sel, v)
14483}
14484
14485func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14486	return graphql.UnmarshalInt(v)
14487}
14488
14489func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14490	return graphql.MarshalInt(v)
14491}
14492
14493func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14494	if v == nil {
14495		return nil, nil
14496	}
14497	res, err := ec.unmarshalOInt2int(ctx, v)
14498	return &res, err
14499}
14500
14501func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14502	if v == nil {
14503		return graphql.Null
14504	}
14505	return ec.marshalOInt2int(ctx, sel, *v)
14506}
14507
14508func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14509	return ec._LabelChangeResult(ctx, sel, &v)
14510}
14511
14512func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14513	if v == nil {
14514		return graphql.Null
14515	}
14516	return ec._LabelChangeResult(ctx, sel, v)
14517}
14518
14519func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14520	return ec._Repository(ctx, sel, &v)
14521}
14522
14523func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14524	if v == nil {
14525		return graphql.Null
14526	}
14527	return ec._Repository(ctx, sel, v)
14528}
14529
14530func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14531	return graphql.UnmarshalString(v)
14532}
14533
14534func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14535	return graphql.MarshalString(v)
14536}
14537
14538func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14539	var vSlice []interface{}
14540	if v != nil {
14541		if tmp1, ok := v.([]interface{}); ok {
14542			vSlice = tmp1
14543		} else {
14544			vSlice = []interface{}{v}
14545		}
14546	}
14547	var err error
14548	res := make([]string, len(vSlice))
14549	for i := range vSlice {
14550		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14551		if err != nil {
14552			return nil, err
14553		}
14554	}
14555	return res, nil
14556}
14557
14558func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14559	if v == nil {
14560		return graphql.Null
14561	}
14562	ret := make(graphql.Array, len(v))
14563	for i := range v {
14564		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14565	}
14566
14567	return ret
14568}
14569
14570func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14571	if v == nil {
14572		return nil, nil
14573	}
14574	res, err := ec.unmarshalOString2string(ctx, v)
14575	return &res, err
14576}
14577
14578func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14579	if v == nil {
14580		return graphql.Null
14581	}
14582	return ec.marshalOString2string(ctx, sel, *v)
14583}
14584
14585func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14586	if v == nil {
14587		return graphql.Null
14588	}
14589	ret := make(graphql.Array, len(v))
14590	var wg sync.WaitGroup
14591	isLen1 := len(v) == 1
14592	if !isLen1 {
14593		wg.Add(len(v))
14594	}
14595	for i := range v {
14596		i := i
14597		fc := &graphql.FieldContext{
14598			Index:  &i,
14599			Result: &v[i],
14600		}
14601		ctx := graphql.WithFieldContext(ctx, fc)
14602		f := func(i int) {
14603			defer func() {
14604				if r := recover(); r != nil {
14605					ec.Error(ctx, ec.Recover(ctx, r))
14606					ret = nil
14607				}
14608			}()
14609			if !isLen1 {
14610				defer wg.Done()
14611			}
14612			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14613		}
14614		if isLen1 {
14615			f(i)
14616		} else {
14617			go f(i)
14618		}
14619
14620	}
14621	wg.Wait()
14622	return ret
14623}
14624
14625func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14626	if v == nil {
14627		return graphql.Null
14628	}
14629	ret := make(graphql.Array, len(v))
14630	var wg sync.WaitGroup
14631	isLen1 := len(v) == 1
14632	if !isLen1 {
14633		wg.Add(len(v))
14634	}
14635	for i := range v {
14636		i := i
14637		fc := &graphql.FieldContext{
14638			Index:  &i,
14639			Result: &v[i],
14640		}
14641		ctx := graphql.WithFieldContext(ctx, fc)
14642		f := func(i int) {
14643			defer func() {
14644				if r := recover(); r != nil {
14645					ec.Error(ctx, ec.Recover(ctx, r))
14646					ret = nil
14647				}
14648			}()
14649			if !isLen1 {
14650				defer wg.Done()
14651			}
14652			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14653		}
14654		if isLen1 {
14655			f(i)
14656		} else {
14657			go f(i)
14658		}
14659
14660	}
14661	wg.Wait()
14662	return ret
14663}
14664
14665func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14666	if v == nil {
14667		return graphql.Null
14668	}
14669	ret := make(graphql.Array, len(v))
14670	var wg sync.WaitGroup
14671	isLen1 := len(v) == 1
14672	if !isLen1 {
14673		wg.Add(len(v))
14674	}
14675	for i := range v {
14676		i := i
14677		fc := &graphql.FieldContext{
14678			Index:  &i,
14679			Result: &v[i],
14680		}
14681		ctx := graphql.WithFieldContext(ctx, fc)
14682		f := func(i int) {
14683			defer func() {
14684				if r := recover(); r != nil {
14685					ec.Error(ctx, ec.Recover(ctx, r))
14686					ret = nil
14687				}
14688			}()
14689			if !isLen1 {
14690				defer wg.Done()
14691			}
14692			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14693		}
14694		if isLen1 {
14695			f(i)
14696		} else {
14697			go f(i)
14698		}
14699
14700	}
14701	wg.Wait()
14702	return ret
14703}
14704
14705func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14706	return ec.___Schema(ctx, sel, &v)
14707}
14708
14709func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14710	if v == nil {
14711		return graphql.Null
14712	}
14713	return ec.___Schema(ctx, sel, v)
14714}
14715
14716func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14717	return ec.___Type(ctx, sel, &v)
14718}
14719
14720func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14721	if v == nil {
14722		return graphql.Null
14723	}
14724	ret := make(graphql.Array, len(v))
14725	var wg sync.WaitGroup
14726	isLen1 := len(v) == 1
14727	if !isLen1 {
14728		wg.Add(len(v))
14729	}
14730	for i := range v {
14731		i := i
14732		fc := &graphql.FieldContext{
14733			Index:  &i,
14734			Result: &v[i],
14735		}
14736		ctx := graphql.WithFieldContext(ctx, fc)
14737		f := func(i int) {
14738			defer func() {
14739				if r := recover(); r != nil {
14740					ec.Error(ctx, ec.Recover(ctx, r))
14741					ret = nil
14742				}
14743			}()
14744			if !isLen1 {
14745				defer wg.Done()
14746			}
14747			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14748		}
14749		if isLen1 {
14750			f(i)
14751		} else {
14752			go f(i)
14753		}
14754
14755	}
14756	wg.Wait()
14757	return ret
14758}
14759
14760func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14761	if v == nil {
14762		return graphql.Null
14763	}
14764	return ec.___Type(ctx, sel, v)
14765}
14766
14767// endregion ***************************** type.gotpl *****************************