1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
    2
    3package graph
    4
    5import (
    6	"bytes"
    7	"context"
    8	"errors"
    9	"fmt"
   10	"image/color"
   11	"strconv"
   12	"sync"
   13	"sync/atomic"
   14	"time"
   15
   16	"github.com/99designs/gqlgen/graphql"
   17	"github.com/99designs/gqlgen/graphql/introspection"
   18	"github.com/MichaelMure/git-bug/bug"
   19	"github.com/MichaelMure/git-bug/graphql/models"
   20	"github.com/MichaelMure/git-bug/util/git"
   21	"github.com/vektah/gqlparser"
   22	"github.com/vektah/gqlparser/ast"
   23)
   24
   25// region    ************************** generated!.gotpl **************************
   26
   27// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
   28func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
   29	return &executableSchema{
   30		resolvers:  cfg.Resolvers,
   31		directives: cfg.Directives,
   32		complexity: cfg.Complexity,
   33	}
   34}
   35
   36type Config struct {
   37	Resolvers  ResolverRoot
   38	Directives DirectiveRoot
   39	Complexity ComplexityRoot
   40}
   41
   42type ResolverRoot interface {
   43	AddCommentOperation() AddCommentOperationResolver
   44	AddCommentTimelineItem() AddCommentTimelineItemResolver
   45	Bug() BugResolver
   46	Color() ColorResolver
   47	Comment() CommentResolver
   48	CommentHistoryStep() CommentHistoryStepResolver
   49	CreateOperation() CreateOperationResolver
   50	CreateTimelineItem() CreateTimelineItemResolver
   51	EditCommentOperation() EditCommentOperationResolver
   52	Identity() IdentityResolver
   53	Label() LabelResolver
   54	LabelChangeOperation() LabelChangeOperationResolver
   55	LabelChangeResult() LabelChangeResultResolver
   56	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
   57	Mutation() MutationResolver
   58	Query() QueryResolver
   59	Repository() RepositoryResolver
   60	SetStatusOperation() SetStatusOperationResolver
   61	SetStatusTimelineItem() SetStatusTimelineItemResolver
   62	SetTitleOperation() SetTitleOperationResolver
   63	SetTitleTimelineItem() SetTitleTimelineItemResolver
   64}
   65
   66type DirectiveRoot struct {
   67}
   68
   69type ComplexityRoot struct {
   70	AddCommentOperation struct {
   71		Author  func(childComplexity int) int
   72		Date    func(childComplexity int) int
   73		Files   func(childComplexity int) int
   74		ID      func(childComplexity int) int
   75		Message func(childComplexity int) int
   76	}
   77
   78	AddCommentPayload struct {
   79		Bug              func(childComplexity int) int
   80		ClientMutationID func(childComplexity int) int
   81		Operation        func(childComplexity int) int
   82	}
   83
   84	AddCommentTimelineItem struct {
   85		Author         func(childComplexity int) int
   86		CreatedAt      func(childComplexity int) int
   87		Edited         func(childComplexity int) int
   88		Files          func(childComplexity int) int
   89		History        func(childComplexity int) int
   90		ID             func(childComplexity int) int
   91		LastEdit       func(childComplexity int) int
   92		Message        func(childComplexity int) int
   93		MessageIsEmpty func(childComplexity int) int
   94	}
   95
   96	Bug struct {
   97		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
   98		Author       func(childComplexity int) int
   99		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
  100		CreatedAt    func(childComplexity int) int
  101		HumanID      func(childComplexity int) int
  102		ID           func(childComplexity int) int
  103		Labels       func(childComplexity int) int
  104		LastEdit     func(childComplexity int) int
  105		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
  106		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
  107		Status       func(childComplexity int) int
  108		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
  109		Title        func(childComplexity int) int
  110	}
  111
  112	BugConnection struct {
  113		Edges      func(childComplexity int) int
  114		Nodes      func(childComplexity int) int
  115		PageInfo   func(childComplexity int) int
  116		TotalCount func(childComplexity int) int
  117	}
  118
  119	BugEdge struct {
  120		Cursor func(childComplexity int) int
  121		Node   func(childComplexity int) int
  122	}
  123
  124	ChangeLabelPayload struct {
  125		Bug              func(childComplexity int) int
  126		ClientMutationID func(childComplexity int) int
  127		Operation        func(childComplexity int) int
  128		Results          func(childComplexity int) int
  129	}
  130
  131	CloseBugPayload struct {
  132		Bug              func(childComplexity int) int
  133		ClientMutationID func(childComplexity int) int
  134		Operation        func(childComplexity int) int
  135	}
  136
  137	Color struct {
  138		B func(childComplexity int) int
  139		G func(childComplexity int) int
  140		R func(childComplexity int) int
  141	}
  142
  143	Comment struct {
  144		Author  func(childComplexity int) int
  145		Files   func(childComplexity int) int
  146		Message func(childComplexity int) int
  147	}
  148
  149	CommentConnection struct {
  150		Edges      func(childComplexity int) int
  151		Nodes      func(childComplexity int) int
  152		PageInfo   func(childComplexity int) int
  153		TotalCount func(childComplexity int) int
  154	}
  155
  156	CommentEdge struct {
  157		Cursor func(childComplexity int) int
  158		Node   func(childComplexity int) int
  159	}
  160
  161	CommentHistoryStep struct {
  162		Date    func(childComplexity int) int
  163		Message func(childComplexity int) int
  164	}
  165
  166	CommitAsNeededPayload struct {
  167		Bug              func(childComplexity int) int
  168		ClientMutationID func(childComplexity int) int
  169	}
  170
  171	CommitPayload struct {
  172		Bug              func(childComplexity int) int
  173		ClientMutationID func(childComplexity int) int
  174	}
  175
  176	CreateOperation struct {
  177		Author  func(childComplexity int) int
  178		Date    func(childComplexity int) int
  179		Files   func(childComplexity int) int
  180		ID      func(childComplexity int) int
  181		Message func(childComplexity int) int
  182		Title   func(childComplexity int) int
  183	}
  184
  185	CreateTimelineItem struct {
  186		Author         func(childComplexity int) int
  187		CreatedAt      func(childComplexity int) int
  188		Edited         func(childComplexity int) int
  189		Files          func(childComplexity int) int
  190		History        func(childComplexity int) int
  191		ID             func(childComplexity int) int
  192		LastEdit       func(childComplexity int) int
  193		Message        func(childComplexity int) int
  194		MessageIsEmpty func(childComplexity int) int
  195	}
  196
  197	EditCommentOperation struct {
  198		Author  func(childComplexity int) int
  199		Date    func(childComplexity int) int
  200		Files   func(childComplexity int) int
  201		ID      func(childComplexity int) int
  202		Message func(childComplexity int) int
  203		Target  func(childComplexity int) int
  204	}
  205
  206	Identity struct {
  207		AvatarUrl   func(childComplexity int) int
  208		DisplayName func(childComplexity int) int
  209		Email       func(childComplexity int) int
  210		HumanID     func(childComplexity int) int
  211		ID          func(childComplexity int) int
  212		IsProtected func(childComplexity int) int
  213		Name        func(childComplexity int) int
  214	}
  215
  216	IdentityConnection struct {
  217		Edges      func(childComplexity int) int
  218		Nodes      func(childComplexity int) int
  219		PageInfo   func(childComplexity int) int
  220		TotalCount func(childComplexity int) int
  221	}
  222
  223	IdentityEdge struct {
  224		Cursor func(childComplexity int) int
  225		Node   func(childComplexity int) int
  226	}
  227
  228	Label struct {
  229		Color func(childComplexity int) int
  230		Name  func(childComplexity int) int
  231	}
  232
  233	LabelChangeOperation struct {
  234		Added   func(childComplexity int) int
  235		Author  func(childComplexity int) int
  236		Date    func(childComplexity int) int
  237		ID      func(childComplexity int) int
  238		Removed func(childComplexity int) int
  239	}
  240
  241	LabelChangeResult struct {
  242		Label  func(childComplexity int) int
  243		Status func(childComplexity int) int
  244	}
  245
  246	LabelChangeTimelineItem struct {
  247		Added   func(childComplexity int) int
  248		Author  func(childComplexity int) int
  249		Date    func(childComplexity int) int
  250		ID      func(childComplexity int) int
  251		Removed func(childComplexity int) int
  252	}
  253
  254	LabelConnection struct {
  255		Edges      func(childComplexity int) int
  256		Nodes      func(childComplexity int) int
  257		PageInfo   func(childComplexity int) int
  258		TotalCount func(childComplexity int) int
  259	}
  260
  261	LabelEdge struct {
  262		Cursor func(childComplexity int) int
  263		Node   func(childComplexity int) int
  264	}
  265
  266	Mutation struct {
  267		AddComment     func(childComplexity int, input models.AddCommentInput) int
  268		ChangeLabels   func(childComplexity int, input *models.ChangeLabelInput) int
  269		CloseBug       func(childComplexity int, input models.CloseBugInput) int
  270		Commit         func(childComplexity int, input models.CommitInput) int
  271		CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
  272		NewBug         func(childComplexity int, input models.NewBugInput) int
  273		OpenBug        func(childComplexity int, input models.OpenBugInput) int
  274		SetTitle       func(childComplexity int, input models.SetTitleInput) int
  275	}
  276
  277	NewBugPayload struct {
  278		Bug              func(childComplexity int) int
  279		ClientMutationID func(childComplexity int) int
  280		Operation        func(childComplexity int) int
  281	}
  282
  283	OpenBugPayload struct {
  284		Bug              func(childComplexity int) int
  285		ClientMutationID func(childComplexity int) int
  286		Operation        func(childComplexity int) int
  287	}
  288
  289	OperationConnection struct {
  290		Edges      func(childComplexity int) int
  291		Nodes      func(childComplexity int) int
  292		PageInfo   func(childComplexity int) int
  293		TotalCount func(childComplexity int) int
  294	}
  295
  296	OperationEdge struct {
  297		Cursor func(childComplexity int) int
  298		Node   func(childComplexity int) int
  299	}
  300
  301	PageInfo struct {
  302		EndCursor       func(childComplexity int) int
  303		HasNextPage     func(childComplexity int) int
  304		HasPreviousPage func(childComplexity int) int
  305		StartCursor     func(childComplexity int) int
  306	}
  307
  308	Query struct {
  309		Repository func(childComplexity int, ref *string) int
  310	}
  311
  312	Repository struct {
  313		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  314		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  315		Bug           func(childComplexity int, prefix string) int
  316		Identity      func(childComplexity int, prefix string) int
  317		UserIdentity  func(childComplexity int) int
  318		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
  319	}
  320
  321	SetStatusOperation struct {
  322		Author func(childComplexity int) int
  323		Date   func(childComplexity int) int
  324		ID     func(childComplexity int) int
  325		Status func(childComplexity int) int
  326	}
  327
  328	SetStatusTimelineItem struct {
  329		Author func(childComplexity int) int
  330		Date   func(childComplexity int) int
  331		ID     func(childComplexity int) int
  332		Status func(childComplexity int) int
  333	}
  334
  335	SetTitleOperation struct {
  336		Author func(childComplexity int) int
  337		Date   func(childComplexity int) int
  338		ID     func(childComplexity int) int
  339		Title  func(childComplexity int) int
  340		Was    func(childComplexity int) int
  341	}
  342
  343	SetTitlePayload struct {
  344		Bug              func(childComplexity int) int
  345		ClientMutationID func(childComplexity int) int
  346		Operation        func(childComplexity int) int
  347	}
  348
  349	SetTitleTimelineItem struct {
  350		Author func(childComplexity int) int
  351		Date   func(childComplexity int) int
  352		ID     func(childComplexity int) int
  353		Title  func(childComplexity int) int
  354		Was    func(childComplexity int) int
  355	}
  356
  357	TimelineItemConnection struct {
  358		Edges      func(childComplexity int) int
  359		Nodes      func(childComplexity int) int
  360		PageInfo   func(childComplexity int) int
  361		TotalCount func(childComplexity int) int
  362	}
  363
  364	TimelineItemEdge struct {
  365		Cursor func(childComplexity int) int
  366		Node   func(childComplexity int) int
  367	}
  368}
  369
  370type AddCommentOperationResolver interface {
  371	ID(ctx context.Context, obj *bug.AddCommentOperation) (string, error)
  372	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
  373	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  374}
  375type AddCommentTimelineItemResolver interface {
  376	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (string, error)
  377	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
  378
  379	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  380	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  381}
  382type BugResolver interface {
  383	ID(ctx context.Context, obj models.BugWrapper) (string, error)
  384	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  385	Status(ctx context.Context, obj models.BugWrapper) (models.Status, error)
  386
  387	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  388	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  389	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  390	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  391	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  392}
  393type ColorResolver interface {
  394	R(ctx context.Context, obj *color.RGBA) (int, error)
  395	G(ctx context.Context, obj *color.RGBA) (int, error)
  396	B(ctx context.Context, obj *color.RGBA) (int, error)
  397}
  398type CommentResolver interface {
  399	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
  400}
  401type CommentHistoryStepResolver interface {
  402	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  403}
  404type CreateOperationResolver interface {
  405	ID(ctx context.Context, obj *bug.CreateOperation) (string, error)
  406	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
  407	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  408}
  409type CreateTimelineItemResolver interface {
  410	ID(ctx context.Context, obj *bug.CreateTimelineItem) (string, error)
  411	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
  412
  413	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  414	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  415}
  416type EditCommentOperationResolver interface {
  417	ID(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  418	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
  419	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  420	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
  421}
  422type IdentityResolver interface {
  423	ID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  424	HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error)
  425}
  426type LabelResolver interface {
  427	Name(ctx context.Context, obj *bug.Label) (string, error)
  428	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  429}
  430type LabelChangeOperationResolver interface {
  431	ID(ctx context.Context, obj *bug.LabelChangeOperation) (string, error)
  432	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
  433	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  434}
  435type LabelChangeResultResolver interface {
  436	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  437}
  438type LabelChangeTimelineItemResolver interface {
  439	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (string, error)
  440	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
  441	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  442}
  443type MutationResolver interface {
  444	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  445	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  446	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  447	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  448	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  449	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  450	Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
  451	CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
  452}
  453type QueryResolver interface {
  454	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  455}
  456type RepositoryResolver interface {
  457	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  458	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  459	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  460	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  461	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  462	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  463}
  464type SetStatusOperationResolver interface {
  465	ID(ctx context.Context, obj *bug.SetStatusOperation) (string, error)
  466	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
  467	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  468	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  469}
  470type SetStatusTimelineItemResolver interface {
  471	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (string, error)
  472	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
  473	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  474	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  475}
  476type SetTitleOperationResolver interface {
  477	ID(ctx context.Context, obj *bug.SetTitleOperation) (string, error)
  478	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
  479	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  480}
  481type SetTitleTimelineItemResolver interface {
  482	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (string, error)
  483	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
  484	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  485}
  486
  487type executableSchema struct {
  488	resolvers  ResolverRoot
  489	directives DirectiveRoot
  490	complexity ComplexityRoot
  491}
  492
  493func (e *executableSchema) Schema() *ast.Schema {
  494	return parsedSchema
  495}
  496
  497func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  498	ec := executionContext{nil, e}
  499	_ = ec
  500	switch typeName + "." + field {
  501
  502	case "AddCommentOperation.author":
  503		if e.complexity.AddCommentOperation.Author == nil {
  504			break
  505		}
  506
  507		return e.complexity.AddCommentOperation.Author(childComplexity), true
  508
  509	case "AddCommentOperation.date":
  510		if e.complexity.AddCommentOperation.Date == nil {
  511			break
  512		}
  513
  514		return e.complexity.AddCommentOperation.Date(childComplexity), true
  515
  516	case "AddCommentOperation.files":
  517		if e.complexity.AddCommentOperation.Files == nil {
  518			break
  519		}
  520
  521		return e.complexity.AddCommentOperation.Files(childComplexity), true
  522
  523	case "AddCommentOperation.id":
  524		if e.complexity.AddCommentOperation.ID == nil {
  525			break
  526		}
  527
  528		return e.complexity.AddCommentOperation.ID(childComplexity), true
  529
  530	case "AddCommentOperation.message":
  531		if e.complexity.AddCommentOperation.Message == nil {
  532			break
  533		}
  534
  535		return e.complexity.AddCommentOperation.Message(childComplexity), true
  536
  537	case "AddCommentPayload.bug":
  538		if e.complexity.AddCommentPayload.Bug == nil {
  539			break
  540		}
  541
  542		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  543
  544	case "AddCommentPayload.clientMutationId":
  545		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  546			break
  547		}
  548
  549		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  550
  551	case "AddCommentPayload.operation":
  552		if e.complexity.AddCommentPayload.Operation == nil {
  553			break
  554		}
  555
  556		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  557
  558	case "AddCommentTimelineItem.author":
  559		if e.complexity.AddCommentTimelineItem.Author == nil {
  560			break
  561		}
  562
  563		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  564
  565	case "AddCommentTimelineItem.createdAt":
  566		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  567			break
  568		}
  569
  570		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  571
  572	case "AddCommentTimelineItem.edited":
  573		if e.complexity.AddCommentTimelineItem.Edited == nil {
  574			break
  575		}
  576
  577		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  578
  579	case "AddCommentTimelineItem.files":
  580		if e.complexity.AddCommentTimelineItem.Files == nil {
  581			break
  582		}
  583
  584		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  585
  586	case "AddCommentTimelineItem.history":
  587		if e.complexity.AddCommentTimelineItem.History == nil {
  588			break
  589		}
  590
  591		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  592
  593	case "AddCommentTimelineItem.id":
  594		if e.complexity.AddCommentTimelineItem.ID == nil {
  595			break
  596		}
  597
  598		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
  599
  600	case "AddCommentTimelineItem.lastEdit":
  601		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  602			break
  603		}
  604
  605		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  606
  607	case "AddCommentTimelineItem.message":
  608		if e.complexity.AddCommentTimelineItem.Message == nil {
  609			break
  610		}
  611
  612		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  613
  614	case "AddCommentTimelineItem.messageIsEmpty":
  615		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  616			break
  617		}
  618
  619		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  620
  621	case "Bug.actors":
  622		if e.complexity.Bug.Actors == nil {
  623			break
  624		}
  625
  626		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  627		if err != nil {
  628			return 0, false
  629		}
  630
  631		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  632
  633	case "Bug.author":
  634		if e.complexity.Bug.Author == nil {
  635			break
  636		}
  637
  638		return e.complexity.Bug.Author(childComplexity), true
  639
  640	case "Bug.comments":
  641		if e.complexity.Bug.Comments == nil {
  642			break
  643		}
  644
  645		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  646		if err != nil {
  647			return 0, false
  648		}
  649
  650		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  651
  652	case "Bug.createdAt":
  653		if e.complexity.Bug.CreatedAt == nil {
  654			break
  655		}
  656
  657		return e.complexity.Bug.CreatedAt(childComplexity), true
  658
  659	case "Bug.humanId":
  660		if e.complexity.Bug.HumanID == nil {
  661			break
  662		}
  663
  664		return e.complexity.Bug.HumanID(childComplexity), true
  665
  666	case "Bug.id":
  667		if e.complexity.Bug.ID == nil {
  668			break
  669		}
  670
  671		return e.complexity.Bug.ID(childComplexity), true
  672
  673	case "Bug.labels":
  674		if e.complexity.Bug.Labels == nil {
  675			break
  676		}
  677
  678		return e.complexity.Bug.Labels(childComplexity), true
  679
  680	case "Bug.lastEdit":
  681		if e.complexity.Bug.LastEdit == nil {
  682			break
  683		}
  684
  685		return e.complexity.Bug.LastEdit(childComplexity), true
  686
  687	case "Bug.operations":
  688		if e.complexity.Bug.Operations == nil {
  689			break
  690		}
  691
  692		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  693		if err != nil {
  694			return 0, false
  695		}
  696
  697		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  698
  699	case "Bug.participants":
  700		if e.complexity.Bug.Participants == nil {
  701			break
  702		}
  703
  704		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  705		if err != nil {
  706			return 0, false
  707		}
  708
  709		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  710
  711	case "Bug.status":
  712		if e.complexity.Bug.Status == nil {
  713			break
  714		}
  715
  716		return e.complexity.Bug.Status(childComplexity), true
  717
  718	case "Bug.timeline":
  719		if e.complexity.Bug.Timeline == nil {
  720			break
  721		}
  722
  723		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  724		if err != nil {
  725			return 0, false
  726		}
  727
  728		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  729
  730	case "Bug.title":
  731		if e.complexity.Bug.Title == nil {
  732			break
  733		}
  734
  735		return e.complexity.Bug.Title(childComplexity), true
  736
  737	case "BugConnection.edges":
  738		if e.complexity.BugConnection.Edges == nil {
  739			break
  740		}
  741
  742		return e.complexity.BugConnection.Edges(childComplexity), true
  743
  744	case "BugConnection.nodes":
  745		if e.complexity.BugConnection.Nodes == nil {
  746			break
  747		}
  748
  749		return e.complexity.BugConnection.Nodes(childComplexity), true
  750
  751	case "BugConnection.pageInfo":
  752		if e.complexity.BugConnection.PageInfo == nil {
  753			break
  754		}
  755
  756		return e.complexity.BugConnection.PageInfo(childComplexity), true
  757
  758	case "BugConnection.totalCount":
  759		if e.complexity.BugConnection.TotalCount == nil {
  760			break
  761		}
  762
  763		return e.complexity.BugConnection.TotalCount(childComplexity), true
  764
  765	case "BugEdge.cursor":
  766		if e.complexity.BugEdge.Cursor == nil {
  767			break
  768		}
  769
  770		return e.complexity.BugEdge.Cursor(childComplexity), true
  771
  772	case "BugEdge.node":
  773		if e.complexity.BugEdge.Node == nil {
  774			break
  775		}
  776
  777		return e.complexity.BugEdge.Node(childComplexity), true
  778
  779	case "ChangeLabelPayload.bug":
  780		if e.complexity.ChangeLabelPayload.Bug == nil {
  781			break
  782		}
  783
  784		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  785
  786	case "ChangeLabelPayload.clientMutationId":
  787		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  788			break
  789		}
  790
  791		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  792
  793	case "ChangeLabelPayload.operation":
  794		if e.complexity.ChangeLabelPayload.Operation == nil {
  795			break
  796		}
  797
  798		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  799
  800	case "ChangeLabelPayload.results":
  801		if e.complexity.ChangeLabelPayload.Results == nil {
  802			break
  803		}
  804
  805		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  806
  807	case "CloseBugPayload.bug":
  808		if e.complexity.CloseBugPayload.Bug == nil {
  809			break
  810		}
  811
  812		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  813
  814	case "CloseBugPayload.clientMutationId":
  815		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  816			break
  817		}
  818
  819		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  820
  821	case "CloseBugPayload.operation":
  822		if e.complexity.CloseBugPayload.Operation == nil {
  823			break
  824		}
  825
  826		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  827
  828	case "Color.B":
  829		if e.complexity.Color.B == nil {
  830			break
  831		}
  832
  833		return e.complexity.Color.B(childComplexity), true
  834
  835	case "Color.G":
  836		if e.complexity.Color.G == nil {
  837			break
  838		}
  839
  840		return e.complexity.Color.G(childComplexity), true
  841
  842	case "Color.R":
  843		if e.complexity.Color.R == nil {
  844			break
  845		}
  846
  847		return e.complexity.Color.R(childComplexity), true
  848
  849	case "Comment.author":
  850		if e.complexity.Comment.Author == nil {
  851			break
  852		}
  853
  854		return e.complexity.Comment.Author(childComplexity), true
  855
  856	case "Comment.files":
  857		if e.complexity.Comment.Files == nil {
  858			break
  859		}
  860
  861		return e.complexity.Comment.Files(childComplexity), true
  862
  863	case "Comment.message":
  864		if e.complexity.Comment.Message == nil {
  865			break
  866		}
  867
  868		return e.complexity.Comment.Message(childComplexity), true
  869
  870	case "CommentConnection.edges":
  871		if e.complexity.CommentConnection.Edges == nil {
  872			break
  873		}
  874
  875		return e.complexity.CommentConnection.Edges(childComplexity), true
  876
  877	case "CommentConnection.nodes":
  878		if e.complexity.CommentConnection.Nodes == nil {
  879			break
  880		}
  881
  882		return e.complexity.CommentConnection.Nodes(childComplexity), true
  883
  884	case "CommentConnection.pageInfo":
  885		if e.complexity.CommentConnection.PageInfo == nil {
  886			break
  887		}
  888
  889		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  890
  891	case "CommentConnection.totalCount":
  892		if e.complexity.CommentConnection.TotalCount == nil {
  893			break
  894		}
  895
  896		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  897
  898	case "CommentEdge.cursor":
  899		if e.complexity.CommentEdge.Cursor == nil {
  900			break
  901		}
  902
  903		return e.complexity.CommentEdge.Cursor(childComplexity), true
  904
  905	case "CommentEdge.node":
  906		if e.complexity.CommentEdge.Node == nil {
  907			break
  908		}
  909
  910		return e.complexity.CommentEdge.Node(childComplexity), true
  911
  912	case "CommentHistoryStep.date":
  913		if e.complexity.CommentHistoryStep.Date == nil {
  914			break
  915		}
  916
  917		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  918
  919	case "CommentHistoryStep.message":
  920		if e.complexity.CommentHistoryStep.Message == nil {
  921			break
  922		}
  923
  924		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  925
  926	case "CommitAsNeededPayload.bug":
  927		if e.complexity.CommitAsNeededPayload.Bug == nil {
  928			break
  929		}
  930
  931		return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
  932
  933	case "CommitAsNeededPayload.clientMutationId":
  934		if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
  935			break
  936		}
  937
  938		return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
  939
  940	case "CommitPayload.bug":
  941		if e.complexity.CommitPayload.Bug == nil {
  942			break
  943		}
  944
  945		return e.complexity.CommitPayload.Bug(childComplexity), true
  946
  947	case "CommitPayload.clientMutationId":
  948		if e.complexity.CommitPayload.ClientMutationID == nil {
  949			break
  950		}
  951
  952		return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
  953
  954	case "CreateOperation.author":
  955		if e.complexity.CreateOperation.Author == nil {
  956			break
  957		}
  958
  959		return e.complexity.CreateOperation.Author(childComplexity), true
  960
  961	case "CreateOperation.date":
  962		if e.complexity.CreateOperation.Date == nil {
  963			break
  964		}
  965
  966		return e.complexity.CreateOperation.Date(childComplexity), true
  967
  968	case "CreateOperation.files":
  969		if e.complexity.CreateOperation.Files == nil {
  970			break
  971		}
  972
  973		return e.complexity.CreateOperation.Files(childComplexity), true
  974
  975	case "CreateOperation.id":
  976		if e.complexity.CreateOperation.ID == nil {
  977			break
  978		}
  979
  980		return e.complexity.CreateOperation.ID(childComplexity), true
  981
  982	case "CreateOperation.message":
  983		if e.complexity.CreateOperation.Message == nil {
  984			break
  985		}
  986
  987		return e.complexity.CreateOperation.Message(childComplexity), true
  988
  989	case "CreateOperation.title":
  990		if e.complexity.CreateOperation.Title == nil {
  991			break
  992		}
  993
  994		return e.complexity.CreateOperation.Title(childComplexity), true
  995
  996	case "CreateTimelineItem.author":
  997		if e.complexity.CreateTimelineItem.Author == nil {
  998			break
  999		}
 1000
 1001		return e.complexity.CreateTimelineItem.Author(childComplexity), true
 1002
 1003	case "CreateTimelineItem.createdAt":
 1004		if e.complexity.CreateTimelineItem.CreatedAt == nil {
 1005			break
 1006		}
 1007
 1008		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
 1009
 1010	case "CreateTimelineItem.edited":
 1011		if e.complexity.CreateTimelineItem.Edited == nil {
 1012			break
 1013		}
 1014
 1015		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
 1016
 1017	case "CreateTimelineItem.files":
 1018		if e.complexity.CreateTimelineItem.Files == nil {
 1019			break
 1020		}
 1021
 1022		return e.complexity.CreateTimelineItem.Files(childComplexity), true
 1023
 1024	case "CreateTimelineItem.history":
 1025		if e.complexity.CreateTimelineItem.History == nil {
 1026			break
 1027		}
 1028
 1029		return e.complexity.CreateTimelineItem.History(childComplexity), true
 1030
 1031	case "CreateTimelineItem.id":
 1032		if e.complexity.CreateTimelineItem.ID == nil {
 1033			break
 1034		}
 1035
 1036		return e.complexity.CreateTimelineItem.ID(childComplexity), true
 1037
 1038	case "CreateTimelineItem.lastEdit":
 1039		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1040			break
 1041		}
 1042
 1043		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1044
 1045	case "CreateTimelineItem.message":
 1046		if e.complexity.CreateTimelineItem.Message == nil {
 1047			break
 1048		}
 1049
 1050		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1051
 1052	case "CreateTimelineItem.messageIsEmpty":
 1053		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1054			break
 1055		}
 1056
 1057		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1058
 1059	case "EditCommentOperation.author":
 1060		if e.complexity.EditCommentOperation.Author == nil {
 1061			break
 1062		}
 1063
 1064		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1065
 1066	case "EditCommentOperation.date":
 1067		if e.complexity.EditCommentOperation.Date == nil {
 1068			break
 1069		}
 1070
 1071		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1072
 1073	case "EditCommentOperation.files":
 1074		if e.complexity.EditCommentOperation.Files == nil {
 1075			break
 1076		}
 1077
 1078		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1079
 1080	case "EditCommentOperation.id":
 1081		if e.complexity.EditCommentOperation.ID == nil {
 1082			break
 1083		}
 1084
 1085		return e.complexity.EditCommentOperation.ID(childComplexity), true
 1086
 1087	case "EditCommentOperation.message":
 1088		if e.complexity.EditCommentOperation.Message == nil {
 1089			break
 1090		}
 1091
 1092		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1093
 1094	case "EditCommentOperation.target":
 1095		if e.complexity.EditCommentOperation.Target == nil {
 1096			break
 1097		}
 1098
 1099		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1100
 1101	case "Identity.avatarUrl":
 1102		if e.complexity.Identity.AvatarUrl == nil {
 1103			break
 1104		}
 1105
 1106		return e.complexity.Identity.AvatarUrl(childComplexity), true
 1107
 1108	case "Identity.displayName":
 1109		if e.complexity.Identity.DisplayName == nil {
 1110			break
 1111		}
 1112
 1113		return e.complexity.Identity.DisplayName(childComplexity), true
 1114
 1115	case "Identity.email":
 1116		if e.complexity.Identity.Email == nil {
 1117			break
 1118		}
 1119
 1120		return e.complexity.Identity.Email(childComplexity), true
 1121
 1122	case "Identity.humanId":
 1123		if e.complexity.Identity.HumanID == nil {
 1124			break
 1125		}
 1126
 1127		return e.complexity.Identity.HumanID(childComplexity), true
 1128
 1129	case "Identity.id":
 1130		if e.complexity.Identity.ID == nil {
 1131			break
 1132		}
 1133
 1134		return e.complexity.Identity.ID(childComplexity), true
 1135
 1136	case "Identity.isProtected":
 1137		if e.complexity.Identity.IsProtected == nil {
 1138			break
 1139		}
 1140
 1141		return e.complexity.Identity.IsProtected(childComplexity), true
 1142
 1143	case "Identity.name":
 1144		if e.complexity.Identity.Name == nil {
 1145			break
 1146		}
 1147
 1148		return e.complexity.Identity.Name(childComplexity), true
 1149
 1150	case "IdentityConnection.edges":
 1151		if e.complexity.IdentityConnection.Edges == nil {
 1152			break
 1153		}
 1154
 1155		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1156
 1157	case "IdentityConnection.nodes":
 1158		if e.complexity.IdentityConnection.Nodes == nil {
 1159			break
 1160		}
 1161
 1162		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1163
 1164	case "IdentityConnection.pageInfo":
 1165		if e.complexity.IdentityConnection.PageInfo == nil {
 1166			break
 1167		}
 1168
 1169		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1170
 1171	case "IdentityConnection.totalCount":
 1172		if e.complexity.IdentityConnection.TotalCount == nil {
 1173			break
 1174		}
 1175
 1176		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1177
 1178	case "IdentityEdge.cursor":
 1179		if e.complexity.IdentityEdge.Cursor == nil {
 1180			break
 1181		}
 1182
 1183		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1184
 1185	case "IdentityEdge.node":
 1186		if e.complexity.IdentityEdge.Node == nil {
 1187			break
 1188		}
 1189
 1190		return e.complexity.IdentityEdge.Node(childComplexity), true
 1191
 1192	case "Label.color":
 1193		if e.complexity.Label.Color == nil {
 1194			break
 1195		}
 1196
 1197		return e.complexity.Label.Color(childComplexity), true
 1198
 1199	case "Label.name":
 1200		if e.complexity.Label.Name == nil {
 1201			break
 1202		}
 1203
 1204		return e.complexity.Label.Name(childComplexity), true
 1205
 1206	case "LabelChangeOperation.added":
 1207		if e.complexity.LabelChangeOperation.Added == nil {
 1208			break
 1209		}
 1210
 1211		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1212
 1213	case "LabelChangeOperation.author":
 1214		if e.complexity.LabelChangeOperation.Author == nil {
 1215			break
 1216		}
 1217
 1218		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1219
 1220	case "LabelChangeOperation.date":
 1221		if e.complexity.LabelChangeOperation.Date == nil {
 1222			break
 1223		}
 1224
 1225		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1226
 1227	case "LabelChangeOperation.id":
 1228		if e.complexity.LabelChangeOperation.ID == nil {
 1229			break
 1230		}
 1231
 1232		return e.complexity.LabelChangeOperation.ID(childComplexity), true
 1233
 1234	case "LabelChangeOperation.removed":
 1235		if e.complexity.LabelChangeOperation.Removed == nil {
 1236			break
 1237		}
 1238
 1239		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1240
 1241	case "LabelChangeResult.label":
 1242		if e.complexity.LabelChangeResult.Label == nil {
 1243			break
 1244		}
 1245
 1246		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1247
 1248	case "LabelChangeResult.status":
 1249		if e.complexity.LabelChangeResult.Status == nil {
 1250			break
 1251		}
 1252
 1253		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1254
 1255	case "LabelChangeTimelineItem.added":
 1256		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1257			break
 1258		}
 1259
 1260		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1261
 1262	case "LabelChangeTimelineItem.author":
 1263		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1264			break
 1265		}
 1266
 1267		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1268
 1269	case "LabelChangeTimelineItem.date":
 1270		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1271			break
 1272		}
 1273
 1274		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1275
 1276	case "LabelChangeTimelineItem.id":
 1277		if e.complexity.LabelChangeTimelineItem.ID == nil {
 1278			break
 1279		}
 1280
 1281		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
 1282
 1283	case "LabelChangeTimelineItem.removed":
 1284		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1285			break
 1286		}
 1287
 1288		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1289
 1290	case "LabelConnection.edges":
 1291		if e.complexity.LabelConnection.Edges == nil {
 1292			break
 1293		}
 1294
 1295		return e.complexity.LabelConnection.Edges(childComplexity), true
 1296
 1297	case "LabelConnection.nodes":
 1298		if e.complexity.LabelConnection.Nodes == nil {
 1299			break
 1300		}
 1301
 1302		return e.complexity.LabelConnection.Nodes(childComplexity), true
 1303
 1304	case "LabelConnection.pageInfo":
 1305		if e.complexity.LabelConnection.PageInfo == nil {
 1306			break
 1307		}
 1308
 1309		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 1310
 1311	case "LabelConnection.totalCount":
 1312		if e.complexity.LabelConnection.TotalCount == nil {
 1313			break
 1314		}
 1315
 1316		return e.complexity.LabelConnection.TotalCount(childComplexity), true
 1317
 1318	case "LabelEdge.cursor":
 1319		if e.complexity.LabelEdge.Cursor == nil {
 1320			break
 1321		}
 1322
 1323		return e.complexity.LabelEdge.Cursor(childComplexity), true
 1324
 1325	case "LabelEdge.node":
 1326		if e.complexity.LabelEdge.Node == nil {
 1327			break
 1328		}
 1329
 1330		return e.complexity.LabelEdge.Node(childComplexity), true
 1331
 1332	case "Mutation.addComment":
 1333		if e.complexity.Mutation.AddComment == nil {
 1334			break
 1335		}
 1336
 1337		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1338		if err != nil {
 1339			return 0, false
 1340		}
 1341
 1342		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1343
 1344	case "Mutation.changeLabels":
 1345		if e.complexity.Mutation.ChangeLabels == nil {
 1346			break
 1347		}
 1348
 1349		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1350		if err != nil {
 1351			return 0, false
 1352		}
 1353
 1354		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1355
 1356	case "Mutation.closeBug":
 1357		if e.complexity.Mutation.CloseBug == nil {
 1358			break
 1359		}
 1360
 1361		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1362		if err != nil {
 1363			return 0, false
 1364		}
 1365
 1366		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1367
 1368	case "Mutation.commit":
 1369		if e.complexity.Mutation.Commit == nil {
 1370			break
 1371		}
 1372
 1373		args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
 1374		if err != nil {
 1375			return 0, false
 1376		}
 1377
 1378		return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
 1379
 1380	case "Mutation.commitAsNeeded":
 1381		if e.complexity.Mutation.CommitAsNeeded == nil {
 1382			break
 1383		}
 1384
 1385		args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
 1386		if err != nil {
 1387			return 0, false
 1388		}
 1389
 1390		return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
 1391
 1392	case "Mutation.newBug":
 1393		if e.complexity.Mutation.NewBug == nil {
 1394			break
 1395		}
 1396
 1397		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1398		if err != nil {
 1399			return 0, false
 1400		}
 1401
 1402		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1403
 1404	case "Mutation.openBug":
 1405		if e.complexity.Mutation.OpenBug == nil {
 1406			break
 1407		}
 1408
 1409		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1410		if err != nil {
 1411			return 0, false
 1412		}
 1413
 1414		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1415
 1416	case "Mutation.setTitle":
 1417		if e.complexity.Mutation.SetTitle == nil {
 1418			break
 1419		}
 1420
 1421		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1422		if err != nil {
 1423			return 0, false
 1424		}
 1425
 1426		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1427
 1428	case "NewBugPayload.bug":
 1429		if e.complexity.NewBugPayload.Bug == nil {
 1430			break
 1431		}
 1432
 1433		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1434
 1435	case "NewBugPayload.clientMutationId":
 1436		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1437			break
 1438		}
 1439
 1440		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1441
 1442	case "NewBugPayload.operation":
 1443		if e.complexity.NewBugPayload.Operation == nil {
 1444			break
 1445		}
 1446
 1447		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1448
 1449	case "OpenBugPayload.bug":
 1450		if e.complexity.OpenBugPayload.Bug == nil {
 1451			break
 1452		}
 1453
 1454		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1455
 1456	case "OpenBugPayload.clientMutationId":
 1457		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1458			break
 1459		}
 1460
 1461		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1462
 1463	case "OpenBugPayload.operation":
 1464		if e.complexity.OpenBugPayload.Operation == nil {
 1465			break
 1466		}
 1467
 1468		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1469
 1470	case "OperationConnection.edges":
 1471		if e.complexity.OperationConnection.Edges == nil {
 1472			break
 1473		}
 1474
 1475		return e.complexity.OperationConnection.Edges(childComplexity), true
 1476
 1477	case "OperationConnection.nodes":
 1478		if e.complexity.OperationConnection.Nodes == nil {
 1479			break
 1480		}
 1481
 1482		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1483
 1484	case "OperationConnection.pageInfo":
 1485		if e.complexity.OperationConnection.PageInfo == nil {
 1486			break
 1487		}
 1488
 1489		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1490
 1491	case "OperationConnection.totalCount":
 1492		if e.complexity.OperationConnection.TotalCount == nil {
 1493			break
 1494		}
 1495
 1496		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1497
 1498	case "OperationEdge.cursor":
 1499		if e.complexity.OperationEdge.Cursor == nil {
 1500			break
 1501		}
 1502
 1503		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1504
 1505	case "OperationEdge.node":
 1506		if e.complexity.OperationEdge.Node == nil {
 1507			break
 1508		}
 1509
 1510		return e.complexity.OperationEdge.Node(childComplexity), true
 1511
 1512	case "PageInfo.endCursor":
 1513		if e.complexity.PageInfo.EndCursor == nil {
 1514			break
 1515		}
 1516
 1517		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1518
 1519	case "PageInfo.hasNextPage":
 1520		if e.complexity.PageInfo.HasNextPage == nil {
 1521			break
 1522		}
 1523
 1524		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1525
 1526	case "PageInfo.hasPreviousPage":
 1527		if e.complexity.PageInfo.HasPreviousPage == nil {
 1528			break
 1529		}
 1530
 1531		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1532
 1533	case "PageInfo.startCursor":
 1534		if e.complexity.PageInfo.StartCursor == nil {
 1535			break
 1536		}
 1537
 1538		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1539
 1540	case "Query.repository":
 1541		if e.complexity.Query.Repository == nil {
 1542			break
 1543		}
 1544
 1545		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1546		if err != nil {
 1547			return 0, false
 1548		}
 1549
 1550		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 1551
 1552	case "Repository.allBugs":
 1553		if e.complexity.Repository.AllBugs == nil {
 1554			break
 1555		}
 1556
 1557		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1558		if err != nil {
 1559			return 0, false
 1560		}
 1561
 1562		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1563
 1564	case "Repository.allIdentities":
 1565		if e.complexity.Repository.AllIdentities == nil {
 1566			break
 1567		}
 1568
 1569		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1570		if err != nil {
 1571			return 0, false
 1572		}
 1573
 1574		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1575
 1576	case "Repository.bug":
 1577		if e.complexity.Repository.Bug == nil {
 1578			break
 1579		}
 1580
 1581		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1582		if err != nil {
 1583			return 0, false
 1584		}
 1585
 1586		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1587
 1588	case "Repository.identity":
 1589		if e.complexity.Repository.Identity == nil {
 1590			break
 1591		}
 1592
 1593		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1594		if err != nil {
 1595			return 0, false
 1596		}
 1597
 1598		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1599
 1600	case "Repository.userIdentity":
 1601		if e.complexity.Repository.UserIdentity == nil {
 1602			break
 1603		}
 1604
 1605		return e.complexity.Repository.UserIdentity(childComplexity), true
 1606
 1607	case "Repository.validLabels":
 1608		if e.complexity.Repository.ValidLabels == nil {
 1609			break
 1610		}
 1611
 1612		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
 1613		if err != nil {
 1614			return 0, false
 1615		}
 1616
 1617		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1618
 1619	case "SetStatusOperation.author":
 1620		if e.complexity.SetStatusOperation.Author == nil {
 1621			break
 1622		}
 1623
 1624		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1625
 1626	case "SetStatusOperation.date":
 1627		if e.complexity.SetStatusOperation.Date == nil {
 1628			break
 1629		}
 1630
 1631		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1632
 1633	case "SetStatusOperation.id":
 1634		if e.complexity.SetStatusOperation.ID == nil {
 1635			break
 1636		}
 1637
 1638		return e.complexity.SetStatusOperation.ID(childComplexity), true
 1639
 1640	case "SetStatusOperation.status":
 1641		if e.complexity.SetStatusOperation.Status == nil {
 1642			break
 1643		}
 1644
 1645		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1646
 1647	case "SetStatusTimelineItem.author":
 1648		if e.complexity.SetStatusTimelineItem.Author == nil {
 1649			break
 1650		}
 1651
 1652		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1653
 1654	case "SetStatusTimelineItem.date":
 1655		if e.complexity.SetStatusTimelineItem.Date == nil {
 1656			break
 1657		}
 1658
 1659		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1660
 1661	case "SetStatusTimelineItem.id":
 1662		if e.complexity.SetStatusTimelineItem.ID == nil {
 1663			break
 1664		}
 1665
 1666		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
 1667
 1668	case "SetStatusTimelineItem.status":
 1669		if e.complexity.SetStatusTimelineItem.Status == nil {
 1670			break
 1671		}
 1672
 1673		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1674
 1675	case "SetTitleOperation.author":
 1676		if e.complexity.SetTitleOperation.Author == nil {
 1677			break
 1678		}
 1679
 1680		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1681
 1682	case "SetTitleOperation.date":
 1683		if e.complexity.SetTitleOperation.Date == nil {
 1684			break
 1685		}
 1686
 1687		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1688
 1689	case "SetTitleOperation.id":
 1690		if e.complexity.SetTitleOperation.ID == nil {
 1691			break
 1692		}
 1693
 1694		return e.complexity.SetTitleOperation.ID(childComplexity), true
 1695
 1696	case "SetTitleOperation.title":
 1697		if e.complexity.SetTitleOperation.Title == nil {
 1698			break
 1699		}
 1700
 1701		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1702
 1703	case "SetTitleOperation.was":
 1704		if e.complexity.SetTitleOperation.Was == nil {
 1705			break
 1706		}
 1707
 1708		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1709
 1710	case "SetTitlePayload.bug":
 1711		if e.complexity.SetTitlePayload.Bug == nil {
 1712			break
 1713		}
 1714
 1715		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1716
 1717	case "SetTitlePayload.clientMutationId":
 1718		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1719			break
 1720		}
 1721
 1722		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1723
 1724	case "SetTitlePayload.operation":
 1725		if e.complexity.SetTitlePayload.Operation == nil {
 1726			break
 1727		}
 1728
 1729		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1730
 1731	case "SetTitleTimelineItem.author":
 1732		if e.complexity.SetTitleTimelineItem.Author == nil {
 1733			break
 1734		}
 1735
 1736		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1737
 1738	case "SetTitleTimelineItem.date":
 1739		if e.complexity.SetTitleTimelineItem.Date == nil {
 1740			break
 1741		}
 1742
 1743		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1744
 1745	case "SetTitleTimelineItem.id":
 1746		if e.complexity.SetTitleTimelineItem.ID == nil {
 1747			break
 1748		}
 1749
 1750		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
 1751
 1752	case "SetTitleTimelineItem.title":
 1753		if e.complexity.SetTitleTimelineItem.Title == nil {
 1754			break
 1755		}
 1756
 1757		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1758
 1759	case "SetTitleTimelineItem.was":
 1760		if e.complexity.SetTitleTimelineItem.Was == nil {
 1761			break
 1762		}
 1763
 1764		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1765
 1766	case "TimelineItemConnection.edges":
 1767		if e.complexity.TimelineItemConnection.Edges == nil {
 1768			break
 1769		}
 1770
 1771		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1772
 1773	case "TimelineItemConnection.nodes":
 1774		if e.complexity.TimelineItemConnection.Nodes == nil {
 1775			break
 1776		}
 1777
 1778		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1779
 1780	case "TimelineItemConnection.pageInfo":
 1781		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1782			break
 1783		}
 1784
 1785		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1786
 1787	case "TimelineItemConnection.totalCount":
 1788		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1789			break
 1790		}
 1791
 1792		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1793
 1794	case "TimelineItemEdge.cursor":
 1795		if e.complexity.TimelineItemEdge.Cursor == nil {
 1796			break
 1797		}
 1798
 1799		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1800
 1801	case "TimelineItemEdge.node":
 1802		if e.complexity.TimelineItemEdge.Node == nil {
 1803			break
 1804		}
 1805
 1806		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1807
 1808	}
 1809	return 0, false
 1810}
 1811
 1812func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
 1813	rc := graphql.GetOperationContext(ctx)
 1814	ec := executionContext{rc, e}
 1815	first := true
 1816
 1817	switch rc.Operation.Operation {
 1818	case ast.Query:
 1819		return func(ctx context.Context) *graphql.Response {
 1820			if !first {
 1821				return nil
 1822			}
 1823			first = false
 1824			data := ec._Query(ctx, rc.Operation.SelectionSet)
 1825			var buf bytes.Buffer
 1826			data.MarshalGQL(&buf)
 1827
 1828			return &graphql.Response{
 1829				Data: buf.Bytes(),
 1830			}
 1831		}
 1832	case ast.Mutation:
 1833		return func(ctx context.Context) *graphql.Response {
 1834			if !first {
 1835				return nil
 1836			}
 1837			first = false
 1838			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
 1839			var buf bytes.Buffer
 1840			data.MarshalGQL(&buf)
 1841
 1842			return &graphql.Response{
 1843				Data: buf.Bytes(),
 1844			}
 1845		}
 1846
 1847	default:
 1848		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
 1849	}
 1850}
 1851
 1852type executionContext struct {
 1853	*graphql.OperationContext
 1854	*executableSchema
 1855}
 1856
 1857func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1858	if ec.DisableIntrospection {
 1859		return nil, errors.New("introspection disabled")
 1860	}
 1861	return introspection.WrapSchema(parsedSchema), nil
 1862}
 1863
 1864func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1865	if ec.DisableIntrospection {
 1866		return nil, errors.New("introspection disabled")
 1867	}
 1868	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1869}
 1870
 1871var sources = []*ast.Source{
 1872	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1873type Comment implements Authored {
 1874  """The author of this comment."""
 1875  author: Identity!
 1876
 1877  """The message of this comment."""
 1878  message: String!
 1879
 1880  """All media's hash referenced in this comment"""
 1881  files: [Hash!]!
 1882}
 1883
 1884type CommentConnection {
 1885  edges: [CommentEdge!]!
 1886  nodes: [Comment!]!
 1887  pageInfo: PageInfo!
 1888  totalCount: Int!
 1889}
 1890
 1891type CommentEdge {
 1892  cursor: String!
 1893  node: Comment!
 1894}
 1895
 1896enum Status {
 1897  OPEN
 1898  CLOSED
 1899}
 1900
 1901type Bug implements Authored {
 1902  """The identifier for this bug"""
 1903  id: String!
 1904  """The human version (truncated) identifier for this bug"""
 1905  humanId: String!
 1906  status: Status!
 1907  title: String!
 1908  labels: [Label!]!
 1909  author: Identity!
 1910  createdAt: Time!
 1911  lastEdit: Time!
 1912
 1913  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1914  actors(
 1915    """Returns the elements in the list that come after the specified cursor."""
 1916    after: String
 1917    """Returns the elements in the list that come before the specified cursor."""
 1918    before: String
 1919    """Returns the first _n_ elements from the list."""
 1920    first: Int
 1921    """Returns the last _n_ elements from the list."""
 1922    last: Int
 1923  ): IdentityConnection!
 1924
 1925  """The participants of the bug. Participants are Identity that have created or
 1926  added a comment on the bug."""
 1927  participants(
 1928    """Returns the elements in the list that come after the specified cursor."""
 1929    after: String
 1930    """Returns the elements in the list that come before the specified cursor."""
 1931    before: String
 1932    """Returns the first _n_ elements from the list."""
 1933    first: Int
 1934    """Returns the last _n_ elements from the list."""
 1935    last: Int
 1936  ): IdentityConnection!
 1937
 1938  comments(
 1939    """Returns the elements in the list that come after the specified cursor."""
 1940    after: String
 1941    """Returns the elements in the list that come before the specified cursor."""
 1942    before: String
 1943    """Returns the first _n_ elements from the list."""
 1944    first: Int
 1945    """Returns the last _n_ elements from the list."""
 1946    last: Int
 1947  ): CommentConnection!
 1948
 1949  timeline(
 1950    """Returns the elements in the list that come after the specified cursor."""
 1951    after: String
 1952    """Returns the elements in the list that come before the specified cursor."""
 1953    before: String
 1954    """Returns the first _n_ elements from the list."""
 1955    first: Int
 1956    """Returns the last _n_ elements from the list."""
 1957    last: Int
 1958  ): TimelineItemConnection!
 1959
 1960  operations(
 1961    """Returns the elements in the list that come after the specified cursor."""
 1962    after: String
 1963    """Returns the elements in the list that come before the specified cursor."""
 1964    before: String
 1965    """Returns the first _n_ elements from the list."""
 1966    first: Int
 1967    """Returns the last _n_ elements from the list."""
 1968    last: Int
 1969  ): OperationConnection!
 1970}
 1971
 1972"""The connection type for Bug."""
 1973type BugConnection {
 1974  """A list of edges."""
 1975  edges: [BugEdge!]!
 1976  nodes: [Bug!]!
 1977  """Information to aid in pagination."""
 1978  pageInfo: PageInfo!
 1979  """Identifies the total count of items in the connection."""
 1980  totalCount: Int!
 1981}
 1982
 1983"""An edge in a connection."""
 1984type BugEdge {
 1985  """A cursor for use in pagination."""
 1986  cursor: String!
 1987  """The item at the end of the edge."""
 1988  node: Bug!
 1989}
 1990`, BuiltIn: false},
 1991	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1992type Identity {
 1993    """The identifier for this identity"""
 1994    id: String!
 1995    """The human version (truncated) identifier for this identity"""
 1996    humanId: String!
 1997    """The name of the person, if known."""
 1998    name: String
 1999    """The email of the person, if known."""
 2000    email: String
 2001    """A non-empty string to display, representing the identity, based on the non-empty values."""
 2002    displayName: String!
 2003    """An url to an avatar"""
 2004    avatarUrl: String
 2005    """isProtected is true if the chain of git commits started to be signed.
 2006    If that's the case, only signed commit with a valid key for this identity can be added."""
 2007    isProtected: Boolean!
 2008}
 2009
 2010type IdentityConnection {
 2011    edges: [IdentityEdge!]!
 2012    nodes: [Identity!]!
 2013    pageInfo: PageInfo!
 2014    totalCount: Int!
 2015}
 2016
 2017type IdentityEdge {
 2018    cursor: String!
 2019    node: Identity!
 2020}`, BuiltIn: false},
 2021	&ast.Source{Name: "schema/label.graphql", Input: `"""Label for a bug."""
 2022type Label {
 2023    """The name of the label."""
 2024    name: String!
 2025    """Color of the label."""
 2026    color: Color!
 2027}
 2028
 2029type LabelConnection {
 2030    edges: [LabelEdge!]!
 2031    nodes: [Label!]!
 2032    pageInfo: PageInfo!
 2033    totalCount: Int!
 2034}
 2035
 2036type LabelEdge {
 2037    cursor: String!
 2038    node: Label!
 2039}`, BuiltIn: false},
 2040	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 2041    """A unique identifier for the client performing the mutation."""
 2042    clientMutationId: String
 2043    """"The name of the repository. If not set, the default repository is used."""
 2044    repoRef: String
 2045    """The title of the new bug."""
 2046    title: String!
 2047    """The first message of the new bug."""
 2048    message: String!
 2049    """The collection of file's hash required for the first message."""
 2050    files: [Hash!]
 2051}
 2052
 2053type NewBugPayload {
 2054    """A unique identifier for the client performing the mutation."""
 2055    clientMutationId: String
 2056    """The created bug."""
 2057    bug: Bug!
 2058    """The resulting operation."""
 2059    operation: CreateOperation!
 2060}
 2061
 2062input AddCommentInput {
 2063    """A unique identifier for the client performing the mutation."""
 2064    clientMutationId: String
 2065    """"The name of the repository. If not set, the default repository is used."""
 2066    repoRef: String
 2067    """The bug ID's prefix."""
 2068    prefix: String!
 2069    """The first message of the new bug."""
 2070    message: String!
 2071    """The collection of file's hash required for the first message."""
 2072    files: [Hash!]
 2073}
 2074
 2075type AddCommentPayload {
 2076    """A unique identifier for the client performing the mutation."""
 2077    clientMutationId: String
 2078    """The affected bug."""
 2079    bug: Bug!
 2080    """The resulting operation."""
 2081    operation: AddCommentOperation!
 2082}
 2083
 2084input ChangeLabelInput {
 2085    """A unique identifier for the client performing the mutation."""
 2086    clientMutationId: String
 2087    """"The name of the repository. If not set, the default repository is used."""
 2088    repoRef: String
 2089    """The bug ID's prefix."""
 2090    prefix: String!
 2091    """The list of label to add."""
 2092    added: [String!]
 2093    """The list of label to remove."""
 2094    Removed: [String!]
 2095}
 2096
 2097enum LabelChangeStatus {
 2098    ADDED
 2099    REMOVED
 2100    DUPLICATE_IN_OP
 2101    ALREADY_EXIST
 2102    DOESNT_EXIST
 2103}
 2104
 2105type LabelChangeResult {
 2106    """The source label."""
 2107    label: Label!
 2108    """The effect this label had."""
 2109    status: LabelChangeStatus!
 2110}
 2111
 2112type ChangeLabelPayload {
 2113    """A unique identifier for the client performing the mutation."""
 2114    clientMutationId: String
 2115    """The affected bug."""
 2116    bug: Bug!
 2117    """The resulting operation."""
 2118    operation: LabelChangeOperation!
 2119    """The effect each source label had."""
 2120    results: [LabelChangeResult]!
 2121}
 2122
 2123input OpenBugInput {
 2124    """A unique identifier for the client performing the mutation."""
 2125    clientMutationId: String
 2126    """"The name of the repository. If not set, the default repository is used."""
 2127    repoRef: String
 2128    """The bug ID's prefix."""
 2129    prefix: String!
 2130}
 2131
 2132type OpenBugPayload {
 2133    """A unique identifier for the client performing the mutation."""
 2134    clientMutationId: String
 2135    """The affected bug."""
 2136    bug: Bug!
 2137    """The resulting operation."""
 2138    operation: SetStatusOperation!
 2139}
 2140
 2141input CloseBugInput {
 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 CloseBugPayload {
 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 SetTitleInput {
 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    """The new title."""
 2167    title: String!
 2168}
 2169
 2170type SetTitlePayload {
 2171    """A unique identifier for the client performing the mutation."""
 2172    clientMutationId: String
 2173    """The affected bug."""
 2174    bug: Bug!
 2175    """The resulting operation"""
 2176    operation: SetTitleOperation!
 2177}
 2178
 2179input CommitInput {
 2180    """A unique identifier for the client performing the mutation."""
 2181    clientMutationId: String
 2182    """"The name of the repository. If not set, the default repository is used."""
 2183    repoRef: String
 2184    """The bug ID's prefix."""
 2185    prefix: String!
 2186}
 2187
 2188type CommitPayload {
 2189    """A unique identifier for the client performing the mutation."""
 2190    clientMutationId: String
 2191    """The affected bug."""
 2192    bug: Bug!
 2193}
 2194
 2195input CommitAsNeededInput {
 2196    """A unique identifier for the client performing the mutation."""
 2197    clientMutationId: String
 2198    """"The name of the repository. If not set, the default repository is used."""
 2199    repoRef: String
 2200    """The bug ID's prefix."""
 2201    prefix: String!
 2202}
 2203
 2204type CommitAsNeededPayload {
 2205    """A unique identifier for the client performing the mutation."""
 2206    clientMutationId: String
 2207    """The affected bug."""
 2208    bug: Bug!
 2209}
 2210`, BuiltIn: false},
 2211	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2212interface Operation {
 2213    """The identifier of the operation"""
 2214    id: String!
 2215    """The operations author."""
 2216    author: Identity!
 2217    """The datetime when this operation was issued."""
 2218    date: Time!
 2219}
 2220
 2221# Connection
 2222
 2223"""The connection type for an Operation"""
 2224type OperationConnection {
 2225    edges: [OperationEdge!]!
 2226    nodes: [Operation!]!
 2227    pageInfo: PageInfo!
 2228    totalCount: Int!
 2229}
 2230
 2231"""Represent an Operation"""
 2232type OperationEdge {
 2233    cursor: String!
 2234    node: Operation!
 2235}
 2236
 2237# Operations
 2238
 2239type CreateOperation implements Operation & Authored {
 2240    """The identifier of the operation"""
 2241    id: String!
 2242    """The author of this object."""
 2243    author: Identity!
 2244    """The datetime when this operation was issued."""
 2245    date: Time!
 2246
 2247    title: String!
 2248    message: String!
 2249    files: [Hash!]!
 2250}
 2251
 2252type SetTitleOperation implements Operation & Authored {
 2253    """The identifier of the operation"""
 2254    id: String!
 2255    """The author of this object."""
 2256    author: Identity!
 2257    """The datetime when this operation was issued."""
 2258    date: Time!
 2259
 2260    title: String!
 2261    was: String!
 2262}
 2263
 2264type AddCommentOperation implements Operation & Authored {
 2265    """The identifier of the operation"""
 2266    id: String!
 2267    """The author of this object."""
 2268    author: Identity!
 2269    """The datetime when this operation was issued."""
 2270    date: Time!
 2271
 2272    message: String!
 2273    files: [Hash!]!
 2274}
 2275
 2276type EditCommentOperation implements Operation & Authored {
 2277    """The identifier of the operation"""
 2278    id: String!
 2279    """The author of this object."""
 2280    author: Identity!
 2281    """The datetime when this operation was issued."""
 2282    date: Time!
 2283
 2284    target: String!
 2285    message: String!
 2286    files: [Hash!]!
 2287}
 2288
 2289type SetStatusOperation implements Operation & Authored {
 2290    """The identifier of the operation"""
 2291    id: String!
 2292    """The author of this object."""
 2293    author: Identity!
 2294    """The datetime when this operation was issued."""
 2295    date: Time!
 2296
 2297    status: Status!
 2298}
 2299
 2300type LabelChangeOperation implements Operation & Authored {
 2301    """The identifier of the operation"""
 2302    id: String!
 2303    """The author of this object."""
 2304    author: Identity!
 2305    """The datetime when this operation was issued."""
 2306    date: Time!
 2307
 2308    added: [Label!]!
 2309    removed: [Label!]!
 2310}
 2311`, BuiltIn: false},
 2312	&ast.Source{Name: "schema/repository.graphql", Input: `
 2313type Repository {
 2314    """All the bugs"""
 2315    allBugs(
 2316        """Returns the elements in the list that come after the specified cursor."""
 2317        after: String
 2318        """Returns the elements in the list that come before the specified cursor."""
 2319        before: String
 2320        """Returns the first _n_ elements from the list."""
 2321        first: Int
 2322        """Returns the last _n_ elements from the list."""
 2323        last: Int
 2324        """A query to select and order bugs"""
 2325        query: String
 2326    ): BugConnection!
 2327
 2328    bug(prefix: String!): Bug
 2329
 2330    """All the identities"""
 2331    allIdentities(
 2332        """Returns the elements in the list that come after the specified cursor."""
 2333        after: String
 2334        """Returns the elements in the list that come before the specified cursor."""
 2335        before: String
 2336        """Returns the first _n_ elements from the list."""
 2337        first: Int
 2338        """Returns the last _n_ elements from the list."""
 2339        last: Int
 2340    ): IdentityConnection!
 2341
 2342    identity(prefix: String!): Identity
 2343
 2344    """The identity created or selected by the user as its own"""
 2345    userIdentity: Identity
 2346
 2347    """List of valid labels."""
 2348    validLabels(
 2349        """Returns the elements in the list that come after the specified cursor."""
 2350        after: String
 2351        """Returns the elements in the list that come before the specified cursor."""
 2352        before: String
 2353        """Returns the first _n_ elements from the list."""
 2354        first: Int
 2355        """Returns the last _n_ elements from the list."""
 2356        last: Int
 2357    ): LabelConnection!
 2358}`, BuiltIn: false},
 2359	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2360    """Access a repository by reference/name. If no ref is given, the default repository is returned if any."""
 2361    repository(ref: String): Repository
 2362}
 2363
 2364type Mutation {
 2365    """Create a new bug"""
 2366    newBug(input: NewBugInput!): NewBugPayload!
 2367    """Add a new comment to a bug"""
 2368    addComment(input: AddCommentInput!): AddCommentPayload!
 2369    """Add or remove a set of label on a bug"""
 2370    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2371    """Change a bug's status to open"""
 2372    openBug(input: OpenBugInput!): OpenBugPayload!
 2373    """Change a bug's status to closed"""
 2374    closeBug(input: CloseBugInput!): CloseBugPayload!
 2375    """Change a bug's title"""
 2376    setTitle(input: SetTitleInput!): SetTitlePayload!
 2377    """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
 2378    commit(input: CommitInput!): CommitPayload!
 2379    """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
 2380    commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
 2381}
 2382`, BuiltIn: false},
 2383	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2384interface TimelineItem {
 2385    """The identifier of the source operation"""
 2386    id: String!
 2387}
 2388
 2389"""CommentHistoryStep hold one version of a message in the history"""
 2390type CommentHistoryStep {
 2391    message: String!
 2392    date: Time!
 2393}
 2394
 2395# Connection
 2396
 2397"""The connection type for TimelineItem"""
 2398type TimelineItemConnection {
 2399    edges: [TimelineItemEdge!]!
 2400    nodes: [TimelineItem!]!
 2401    pageInfo: PageInfo!
 2402    totalCount: Int!
 2403}
 2404
 2405"""Represent a TimelineItem"""
 2406type TimelineItemEdge {
 2407    cursor: String!
 2408    node: TimelineItem!
 2409}
 2410
 2411# Items
 2412
 2413"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2414type CreateTimelineItem implements TimelineItem & Authored {
 2415    """The identifier of the source operation"""
 2416    id: String!
 2417    author: Identity!
 2418    message: String!
 2419    messageIsEmpty: Boolean!
 2420    files: [Hash!]!
 2421    createdAt: Time!
 2422    lastEdit: Time!
 2423    edited: Boolean!
 2424    history: [CommentHistoryStep!]!
 2425}
 2426
 2427"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2428type AddCommentTimelineItem implements TimelineItem & Authored {
 2429    """The identifier of the source operation"""
 2430    id: String!
 2431    author: Identity!
 2432    message: String!
 2433    messageIsEmpty: Boolean!
 2434    files: [Hash!]!
 2435    createdAt: Time!
 2436    lastEdit: Time!
 2437    edited: Boolean!
 2438    history: [CommentHistoryStep!]!
 2439}
 2440
 2441"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2442type LabelChangeTimelineItem implements TimelineItem & Authored {
 2443    """The identifier of the source operation"""
 2444    id: String!
 2445    author: Identity!
 2446    date: Time!
 2447    added: [Label!]!
 2448    removed: [Label!]!
 2449}
 2450
 2451"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2452type SetStatusTimelineItem implements TimelineItem & Authored {
 2453    """The identifier of the source operation"""
 2454    id: String!
 2455    author: Identity!
 2456    date: Time!
 2457    status: Status!
 2458}
 2459
 2460"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2461type SetTitleTimelineItem implements TimelineItem & Authored {
 2462    """The identifier of the source operation"""
 2463    id: String!
 2464    author: Identity!
 2465    date: Time!
 2466    title: String!
 2467    was: String!
 2468}
 2469`, BuiltIn: false},
 2470	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2471scalar Hash
 2472
 2473"""Defines a color by red, green and blue components."""
 2474type Color {
 2475    """Red component of the color."""
 2476    R: Int!
 2477    """Green component of the color."""
 2478    G: Int!
 2479    """Blue component of the color."""
 2480    B: Int!
 2481}
 2482
 2483"""Information about pagination in a connection."""
 2484type PageInfo {
 2485    """When paginating forwards, are there more items?"""
 2486    hasNextPage: Boolean!
 2487    """When paginating backwards, are there more items?"""
 2488    hasPreviousPage: Boolean!
 2489    """When paginating backwards, the cursor to continue."""
 2490    startCursor: String!
 2491    """When paginating forwards, the cursor to continue."""
 2492    endCursor: String!
 2493}
 2494
 2495"""An object that has an author."""
 2496interface Authored {
 2497    """The author of this object."""
 2498    author: Identity!
 2499}
 2500`, BuiltIn: false},
 2501}
 2502var parsedSchema = gqlparser.MustLoadSchema(sources...)
 2503
 2504// endregion ************************** generated!.gotpl **************************
 2505
 2506// region    ***************************** args.gotpl *****************************
 2507
 2508func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2509	var err error
 2510	args := map[string]interface{}{}
 2511	var arg0 *string
 2512	if tmp, ok := rawArgs["after"]; ok {
 2513		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2514		if err != nil {
 2515			return nil, err
 2516		}
 2517	}
 2518	args["after"] = arg0
 2519	var arg1 *string
 2520	if tmp, ok := rawArgs["before"]; ok {
 2521		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2522		if err != nil {
 2523			return nil, err
 2524		}
 2525	}
 2526	args["before"] = arg1
 2527	var arg2 *int
 2528	if tmp, ok := rawArgs["first"]; ok {
 2529		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2530		if err != nil {
 2531			return nil, err
 2532		}
 2533	}
 2534	args["first"] = arg2
 2535	var arg3 *int
 2536	if tmp, ok := rawArgs["last"]; ok {
 2537		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2538		if err != nil {
 2539			return nil, err
 2540		}
 2541	}
 2542	args["last"] = arg3
 2543	return args, nil
 2544}
 2545
 2546func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2547	var err error
 2548	args := map[string]interface{}{}
 2549	var arg0 *string
 2550	if tmp, ok := rawArgs["after"]; ok {
 2551		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2552		if err != nil {
 2553			return nil, err
 2554		}
 2555	}
 2556	args["after"] = arg0
 2557	var arg1 *string
 2558	if tmp, ok := rawArgs["before"]; ok {
 2559		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2560		if err != nil {
 2561			return nil, err
 2562		}
 2563	}
 2564	args["before"] = arg1
 2565	var arg2 *int
 2566	if tmp, ok := rawArgs["first"]; ok {
 2567		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2568		if err != nil {
 2569			return nil, err
 2570		}
 2571	}
 2572	args["first"] = arg2
 2573	var arg3 *int
 2574	if tmp, ok := rawArgs["last"]; ok {
 2575		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2576		if err != nil {
 2577			return nil, err
 2578		}
 2579	}
 2580	args["last"] = arg3
 2581	return args, nil
 2582}
 2583
 2584func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2585	var err error
 2586	args := map[string]interface{}{}
 2587	var arg0 *string
 2588	if tmp, ok := rawArgs["after"]; ok {
 2589		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2590		if err != nil {
 2591			return nil, err
 2592		}
 2593	}
 2594	args["after"] = arg0
 2595	var arg1 *string
 2596	if tmp, ok := rawArgs["before"]; ok {
 2597		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2598		if err != nil {
 2599			return nil, err
 2600		}
 2601	}
 2602	args["before"] = arg1
 2603	var arg2 *int
 2604	if tmp, ok := rawArgs["first"]; ok {
 2605		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2606		if err != nil {
 2607			return nil, err
 2608		}
 2609	}
 2610	args["first"] = arg2
 2611	var arg3 *int
 2612	if tmp, ok := rawArgs["last"]; ok {
 2613		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2614		if err != nil {
 2615			return nil, err
 2616		}
 2617	}
 2618	args["last"] = arg3
 2619	return args, nil
 2620}
 2621
 2622func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2623	var err error
 2624	args := map[string]interface{}{}
 2625	var arg0 *string
 2626	if tmp, ok := rawArgs["after"]; ok {
 2627		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2628		if err != nil {
 2629			return nil, err
 2630		}
 2631	}
 2632	args["after"] = arg0
 2633	var arg1 *string
 2634	if tmp, ok := rawArgs["before"]; ok {
 2635		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2636		if err != nil {
 2637			return nil, err
 2638		}
 2639	}
 2640	args["before"] = arg1
 2641	var arg2 *int
 2642	if tmp, ok := rawArgs["first"]; ok {
 2643		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2644		if err != nil {
 2645			return nil, err
 2646		}
 2647	}
 2648	args["first"] = arg2
 2649	var arg3 *int
 2650	if tmp, ok := rawArgs["last"]; ok {
 2651		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2652		if err != nil {
 2653			return nil, err
 2654		}
 2655	}
 2656	args["last"] = arg3
 2657	return args, nil
 2658}
 2659
 2660func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2661	var err error
 2662	args := map[string]interface{}{}
 2663	var arg0 *string
 2664	if tmp, ok := rawArgs["after"]; ok {
 2665		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2666		if err != nil {
 2667			return nil, err
 2668		}
 2669	}
 2670	args["after"] = arg0
 2671	var arg1 *string
 2672	if tmp, ok := rawArgs["before"]; ok {
 2673		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2674		if err != nil {
 2675			return nil, err
 2676		}
 2677	}
 2678	args["before"] = arg1
 2679	var arg2 *int
 2680	if tmp, ok := rawArgs["first"]; ok {
 2681		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2682		if err != nil {
 2683			return nil, err
 2684		}
 2685	}
 2686	args["first"] = arg2
 2687	var arg3 *int
 2688	if tmp, ok := rawArgs["last"]; ok {
 2689		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2690		if err != nil {
 2691			return nil, err
 2692		}
 2693	}
 2694	args["last"] = arg3
 2695	return args, nil
 2696}
 2697
 2698func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2699	var err error
 2700	args := map[string]interface{}{}
 2701	var arg0 models.AddCommentInput
 2702	if tmp, ok := rawArgs["input"]; ok {
 2703		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2704		if err != nil {
 2705			return nil, err
 2706		}
 2707	}
 2708	args["input"] = arg0
 2709	return args, nil
 2710}
 2711
 2712func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2713	var err error
 2714	args := map[string]interface{}{}
 2715	var arg0 *models.ChangeLabelInput
 2716	if tmp, ok := rawArgs["input"]; ok {
 2717		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2718		if err != nil {
 2719			return nil, err
 2720		}
 2721	}
 2722	args["input"] = arg0
 2723	return args, nil
 2724}
 2725
 2726func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2727	var err error
 2728	args := map[string]interface{}{}
 2729	var arg0 models.CloseBugInput
 2730	if tmp, ok := rawArgs["input"]; ok {
 2731		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2732		if err != nil {
 2733			return nil, err
 2734		}
 2735	}
 2736	args["input"] = arg0
 2737	return args, nil
 2738}
 2739
 2740func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2741	var err error
 2742	args := map[string]interface{}{}
 2743	var arg0 models.CommitAsNeededInput
 2744	if tmp, ok := rawArgs["input"]; ok {
 2745		arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
 2746		if err != nil {
 2747			return nil, err
 2748		}
 2749	}
 2750	args["input"] = arg0
 2751	return args, nil
 2752}
 2753
 2754func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2755	var err error
 2756	args := map[string]interface{}{}
 2757	var arg0 models.CommitInput
 2758	if tmp, ok := rawArgs["input"]; ok {
 2759		arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
 2760		if err != nil {
 2761			return nil, err
 2762		}
 2763	}
 2764	args["input"] = arg0
 2765	return args, nil
 2766}
 2767
 2768func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2769	var err error
 2770	args := map[string]interface{}{}
 2771	var arg0 models.NewBugInput
 2772	if tmp, ok := rawArgs["input"]; ok {
 2773		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2774		if err != nil {
 2775			return nil, err
 2776		}
 2777	}
 2778	args["input"] = arg0
 2779	return args, nil
 2780}
 2781
 2782func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2783	var err error
 2784	args := map[string]interface{}{}
 2785	var arg0 models.OpenBugInput
 2786	if tmp, ok := rawArgs["input"]; ok {
 2787		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2788		if err != nil {
 2789			return nil, err
 2790		}
 2791	}
 2792	args["input"] = arg0
 2793	return args, nil
 2794}
 2795
 2796func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2797	var err error
 2798	args := map[string]interface{}{}
 2799	var arg0 models.SetTitleInput
 2800	if tmp, ok := rawArgs["input"]; ok {
 2801		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2802		if err != nil {
 2803			return nil, err
 2804		}
 2805	}
 2806	args["input"] = arg0
 2807	return args, nil
 2808}
 2809
 2810func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2811	var err error
 2812	args := map[string]interface{}{}
 2813	var arg0 string
 2814	if tmp, ok := rawArgs["name"]; ok {
 2815		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2816		if err != nil {
 2817			return nil, err
 2818		}
 2819	}
 2820	args["name"] = arg0
 2821	return args, nil
 2822}
 2823
 2824func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2825	var err error
 2826	args := map[string]interface{}{}
 2827	var arg0 *string
 2828	if tmp, ok := rawArgs["ref"]; ok {
 2829		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2830		if err != nil {
 2831			return nil, err
 2832		}
 2833	}
 2834	args["ref"] = arg0
 2835	return args, nil
 2836}
 2837
 2838func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2839	var err error
 2840	args := map[string]interface{}{}
 2841	var arg0 *string
 2842	if tmp, ok := rawArgs["after"]; ok {
 2843		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2844		if err != nil {
 2845			return nil, err
 2846		}
 2847	}
 2848	args["after"] = arg0
 2849	var arg1 *string
 2850	if tmp, ok := rawArgs["before"]; ok {
 2851		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2852		if err != nil {
 2853			return nil, err
 2854		}
 2855	}
 2856	args["before"] = arg1
 2857	var arg2 *int
 2858	if tmp, ok := rawArgs["first"]; ok {
 2859		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2860		if err != nil {
 2861			return nil, err
 2862		}
 2863	}
 2864	args["first"] = arg2
 2865	var arg3 *int
 2866	if tmp, ok := rawArgs["last"]; ok {
 2867		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2868		if err != nil {
 2869			return nil, err
 2870		}
 2871	}
 2872	args["last"] = arg3
 2873	var arg4 *string
 2874	if tmp, ok := rawArgs["query"]; ok {
 2875		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2876		if err != nil {
 2877			return nil, err
 2878		}
 2879	}
 2880	args["query"] = arg4
 2881	return args, nil
 2882}
 2883
 2884func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2885	var err error
 2886	args := map[string]interface{}{}
 2887	var arg0 *string
 2888	if tmp, ok := rawArgs["after"]; ok {
 2889		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2890		if err != nil {
 2891			return nil, err
 2892		}
 2893	}
 2894	args["after"] = arg0
 2895	var arg1 *string
 2896	if tmp, ok := rawArgs["before"]; ok {
 2897		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2898		if err != nil {
 2899			return nil, err
 2900		}
 2901	}
 2902	args["before"] = arg1
 2903	var arg2 *int
 2904	if tmp, ok := rawArgs["first"]; ok {
 2905		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2906		if err != nil {
 2907			return nil, err
 2908		}
 2909	}
 2910	args["first"] = arg2
 2911	var arg3 *int
 2912	if tmp, ok := rawArgs["last"]; ok {
 2913		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2914		if err != nil {
 2915			return nil, err
 2916		}
 2917	}
 2918	args["last"] = arg3
 2919	return args, nil
 2920}
 2921
 2922func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2923	var err error
 2924	args := map[string]interface{}{}
 2925	var arg0 string
 2926	if tmp, ok := rawArgs["prefix"]; ok {
 2927		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2928		if err != nil {
 2929			return nil, err
 2930		}
 2931	}
 2932	args["prefix"] = arg0
 2933	return args, nil
 2934}
 2935
 2936func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2937	var err error
 2938	args := map[string]interface{}{}
 2939	var arg0 string
 2940	if tmp, ok := rawArgs["prefix"]; ok {
 2941		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2942		if err != nil {
 2943			return nil, err
 2944		}
 2945	}
 2946	args["prefix"] = arg0
 2947	return args, nil
 2948}
 2949
 2950func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2951	var err error
 2952	args := map[string]interface{}{}
 2953	var arg0 *string
 2954	if tmp, ok := rawArgs["after"]; ok {
 2955		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2956		if err != nil {
 2957			return nil, err
 2958		}
 2959	}
 2960	args["after"] = arg0
 2961	var arg1 *string
 2962	if tmp, ok := rawArgs["before"]; ok {
 2963		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2964		if err != nil {
 2965			return nil, err
 2966		}
 2967	}
 2968	args["before"] = arg1
 2969	var arg2 *int
 2970	if tmp, ok := rawArgs["first"]; ok {
 2971		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2972		if err != nil {
 2973			return nil, err
 2974		}
 2975	}
 2976	args["first"] = arg2
 2977	var arg3 *int
 2978	if tmp, ok := rawArgs["last"]; ok {
 2979		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2980		if err != nil {
 2981			return nil, err
 2982		}
 2983	}
 2984	args["last"] = arg3
 2985	return args, nil
 2986}
 2987
 2988func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2989	var err error
 2990	args := map[string]interface{}{}
 2991	var arg0 bool
 2992	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2993		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2994		if err != nil {
 2995			return nil, err
 2996		}
 2997	}
 2998	args["includeDeprecated"] = arg0
 2999	return args, nil
 3000}
 3001
 3002func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 3003	var err error
 3004	args := map[string]interface{}{}
 3005	var arg0 bool
 3006	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 3007		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 3008		if err != nil {
 3009			return nil, err
 3010		}
 3011	}
 3012	args["includeDeprecated"] = arg0
 3013	return args, nil
 3014}
 3015
 3016// endregion ***************************** args.gotpl *****************************
 3017
 3018// region    ************************** directives.gotpl **************************
 3019
 3020// endregion ************************** directives.gotpl **************************
 3021
 3022// region    **************************** field.gotpl *****************************
 3023
 3024func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3025	defer func() {
 3026		if r := recover(); r != nil {
 3027			ec.Error(ctx, ec.Recover(ctx, r))
 3028			ret = graphql.Null
 3029		}
 3030	}()
 3031	fc := &graphql.FieldContext{
 3032		Object:   "AddCommentOperation",
 3033		Field:    field,
 3034		Args:     nil,
 3035		IsMethod: true,
 3036	}
 3037
 3038	ctx = graphql.WithFieldContext(ctx, fc)
 3039	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3040		ctx = rctx // use context from middleware stack in children
 3041		return ec.resolvers.AddCommentOperation().ID(rctx, obj)
 3042	})
 3043	if err != nil {
 3044		ec.Error(ctx, err)
 3045		return graphql.Null
 3046	}
 3047	if resTmp == nil {
 3048		if !graphql.HasFieldError(ctx, fc) {
 3049			ec.Errorf(ctx, "must not be null")
 3050		}
 3051		return graphql.Null
 3052	}
 3053	res := resTmp.(string)
 3054	fc.Result = res
 3055	return ec.marshalNString2string(ctx, field.Selections, res)
 3056}
 3057
 3058func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3059	defer func() {
 3060		if r := recover(); r != nil {
 3061			ec.Error(ctx, ec.Recover(ctx, r))
 3062			ret = graphql.Null
 3063		}
 3064	}()
 3065	fc := &graphql.FieldContext{
 3066		Object:   "AddCommentOperation",
 3067		Field:    field,
 3068		Args:     nil,
 3069		IsMethod: true,
 3070	}
 3071
 3072	ctx = graphql.WithFieldContext(ctx, fc)
 3073	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3074		ctx = rctx // use context from middleware stack in children
 3075		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
 3076	})
 3077	if err != nil {
 3078		ec.Error(ctx, err)
 3079		return graphql.Null
 3080	}
 3081	if resTmp == nil {
 3082		if !graphql.HasFieldError(ctx, fc) {
 3083			ec.Errorf(ctx, "must not be null")
 3084		}
 3085		return graphql.Null
 3086	}
 3087	res := resTmp.(models.IdentityWrapper)
 3088	fc.Result = res
 3089	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3090}
 3091
 3092func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3093	defer func() {
 3094		if r := recover(); r != nil {
 3095			ec.Error(ctx, ec.Recover(ctx, r))
 3096			ret = graphql.Null
 3097		}
 3098	}()
 3099	fc := &graphql.FieldContext{
 3100		Object:   "AddCommentOperation",
 3101		Field:    field,
 3102		Args:     nil,
 3103		IsMethod: true,
 3104	}
 3105
 3106	ctx = graphql.WithFieldContext(ctx, fc)
 3107	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3108		ctx = rctx // use context from middleware stack in children
 3109		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 3110	})
 3111	if err != nil {
 3112		ec.Error(ctx, err)
 3113		return graphql.Null
 3114	}
 3115	if resTmp == nil {
 3116		if !graphql.HasFieldError(ctx, fc) {
 3117			ec.Errorf(ctx, "must not be null")
 3118		}
 3119		return graphql.Null
 3120	}
 3121	res := resTmp.(*time.Time)
 3122	fc.Result = res
 3123	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3124}
 3125
 3126func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3127	defer func() {
 3128		if r := recover(); r != nil {
 3129			ec.Error(ctx, ec.Recover(ctx, r))
 3130			ret = graphql.Null
 3131		}
 3132	}()
 3133	fc := &graphql.FieldContext{
 3134		Object:   "AddCommentOperation",
 3135		Field:    field,
 3136		Args:     nil,
 3137		IsMethod: false,
 3138	}
 3139
 3140	ctx = graphql.WithFieldContext(ctx, fc)
 3141	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3142		ctx = rctx // use context from middleware stack in children
 3143		return obj.Message, nil
 3144	})
 3145	if err != nil {
 3146		ec.Error(ctx, err)
 3147		return graphql.Null
 3148	}
 3149	if resTmp == nil {
 3150		if !graphql.HasFieldError(ctx, fc) {
 3151			ec.Errorf(ctx, "must not be null")
 3152		}
 3153		return graphql.Null
 3154	}
 3155	res := resTmp.(string)
 3156	fc.Result = res
 3157	return ec.marshalNString2string(ctx, field.Selections, res)
 3158}
 3159
 3160func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3161	defer func() {
 3162		if r := recover(); r != nil {
 3163			ec.Error(ctx, ec.Recover(ctx, r))
 3164			ret = graphql.Null
 3165		}
 3166	}()
 3167	fc := &graphql.FieldContext{
 3168		Object:   "AddCommentOperation",
 3169		Field:    field,
 3170		Args:     nil,
 3171		IsMethod: false,
 3172	}
 3173
 3174	ctx = graphql.WithFieldContext(ctx, fc)
 3175	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3176		ctx = rctx // use context from middleware stack in children
 3177		return obj.Files, nil
 3178	})
 3179	if err != nil {
 3180		ec.Error(ctx, err)
 3181		return graphql.Null
 3182	}
 3183	if resTmp == nil {
 3184		if !graphql.HasFieldError(ctx, fc) {
 3185			ec.Errorf(ctx, "must not be null")
 3186		}
 3187		return graphql.Null
 3188	}
 3189	res := resTmp.([]git.Hash)
 3190	fc.Result = res
 3191	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3192}
 3193
 3194func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3195	defer func() {
 3196		if r := recover(); r != nil {
 3197			ec.Error(ctx, ec.Recover(ctx, r))
 3198			ret = graphql.Null
 3199		}
 3200	}()
 3201	fc := &graphql.FieldContext{
 3202		Object:   "AddCommentPayload",
 3203		Field:    field,
 3204		Args:     nil,
 3205		IsMethod: false,
 3206	}
 3207
 3208	ctx = graphql.WithFieldContext(ctx, fc)
 3209	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3210		ctx = rctx // use context from middleware stack in children
 3211		return obj.ClientMutationID, nil
 3212	})
 3213	if err != nil {
 3214		ec.Error(ctx, err)
 3215		return graphql.Null
 3216	}
 3217	if resTmp == nil {
 3218		return graphql.Null
 3219	}
 3220	res := resTmp.(*string)
 3221	fc.Result = res
 3222	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3223}
 3224
 3225func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3226	defer func() {
 3227		if r := recover(); r != nil {
 3228			ec.Error(ctx, ec.Recover(ctx, r))
 3229			ret = graphql.Null
 3230		}
 3231	}()
 3232	fc := &graphql.FieldContext{
 3233		Object:   "AddCommentPayload",
 3234		Field:    field,
 3235		Args:     nil,
 3236		IsMethod: false,
 3237	}
 3238
 3239	ctx = graphql.WithFieldContext(ctx, fc)
 3240	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3241		ctx = rctx // use context from middleware stack in children
 3242		return obj.Bug, nil
 3243	})
 3244	if err != nil {
 3245		ec.Error(ctx, err)
 3246		return graphql.Null
 3247	}
 3248	if resTmp == nil {
 3249		if !graphql.HasFieldError(ctx, fc) {
 3250			ec.Errorf(ctx, "must not be null")
 3251		}
 3252		return graphql.Null
 3253	}
 3254	res := resTmp.(models.BugWrapper)
 3255	fc.Result = res
 3256	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 3257}
 3258
 3259func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3260	defer func() {
 3261		if r := recover(); r != nil {
 3262			ec.Error(ctx, ec.Recover(ctx, r))
 3263			ret = graphql.Null
 3264		}
 3265	}()
 3266	fc := &graphql.FieldContext{
 3267		Object:   "AddCommentPayload",
 3268		Field:    field,
 3269		Args:     nil,
 3270		IsMethod: false,
 3271	}
 3272
 3273	ctx = graphql.WithFieldContext(ctx, fc)
 3274	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3275		ctx = rctx // use context from middleware stack in children
 3276		return obj.Operation, nil
 3277	})
 3278	if err != nil {
 3279		ec.Error(ctx, err)
 3280		return graphql.Null
 3281	}
 3282	if resTmp == nil {
 3283		if !graphql.HasFieldError(ctx, fc) {
 3284			ec.Errorf(ctx, "must not be null")
 3285		}
 3286		return graphql.Null
 3287	}
 3288	res := resTmp.(*bug.AddCommentOperation)
 3289	fc.Result = res
 3290	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3291}
 3292
 3293func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3294	defer func() {
 3295		if r := recover(); r != nil {
 3296			ec.Error(ctx, ec.Recover(ctx, r))
 3297			ret = graphql.Null
 3298		}
 3299	}()
 3300	fc := &graphql.FieldContext{
 3301		Object:   "AddCommentTimelineItem",
 3302		Field:    field,
 3303		Args:     nil,
 3304		IsMethod: true,
 3305	}
 3306
 3307	ctx = graphql.WithFieldContext(ctx, fc)
 3308	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3309		ctx = rctx // use context from middleware stack in children
 3310		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
 3311	})
 3312	if err != nil {
 3313		ec.Error(ctx, err)
 3314		return graphql.Null
 3315	}
 3316	if resTmp == nil {
 3317		if !graphql.HasFieldError(ctx, fc) {
 3318			ec.Errorf(ctx, "must not be null")
 3319		}
 3320		return graphql.Null
 3321	}
 3322	res := resTmp.(string)
 3323	fc.Result = res
 3324	return ec.marshalNString2string(ctx, field.Selections, res)
 3325}
 3326
 3327func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3328	defer func() {
 3329		if r := recover(); r != nil {
 3330			ec.Error(ctx, ec.Recover(ctx, r))
 3331			ret = graphql.Null
 3332		}
 3333	}()
 3334	fc := &graphql.FieldContext{
 3335		Object:   "AddCommentTimelineItem",
 3336		Field:    field,
 3337		Args:     nil,
 3338		IsMethod: true,
 3339	}
 3340
 3341	ctx = graphql.WithFieldContext(ctx, fc)
 3342	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3343		ctx = rctx // use context from middleware stack in children
 3344		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
 3345	})
 3346	if err != nil {
 3347		ec.Error(ctx, err)
 3348		return graphql.Null
 3349	}
 3350	if resTmp == nil {
 3351		if !graphql.HasFieldError(ctx, fc) {
 3352			ec.Errorf(ctx, "must not be null")
 3353		}
 3354		return graphql.Null
 3355	}
 3356	res := resTmp.(models.IdentityWrapper)
 3357	fc.Result = res
 3358	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3359}
 3360
 3361func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3362	defer func() {
 3363		if r := recover(); r != nil {
 3364			ec.Error(ctx, ec.Recover(ctx, r))
 3365			ret = graphql.Null
 3366		}
 3367	}()
 3368	fc := &graphql.FieldContext{
 3369		Object:   "AddCommentTimelineItem",
 3370		Field:    field,
 3371		Args:     nil,
 3372		IsMethod: false,
 3373	}
 3374
 3375	ctx = graphql.WithFieldContext(ctx, fc)
 3376	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3377		ctx = rctx // use context from middleware stack in children
 3378		return obj.Message, nil
 3379	})
 3380	if err != nil {
 3381		ec.Error(ctx, err)
 3382		return graphql.Null
 3383	}
 3384	if resTmp == nil {
 3385		if !graphql.HasFieldError(ctx, fc) {
 3386			ec.Errorf(ctx, "must not be null")
 3387		}
 3388		return graphql.Null
 3389	}
 3390	res := resTmp.(string)
 3391	fc.Result = res
 3392	return ec.marshalNString2string(ctx, field.Selections, res)
 3393}
 3394
 3395func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3396	defer func() {
 3397		if r := recover(); r != nil {
 3398			ec.Error(ctx, ec.Recover(ctx, r))
 3399			ret = graphql.Null
 3400		}
 3401	}()
 3402	fc := &graphql.FieldContext{
 3403		Object:   "AddCommentTimelineItem",
 3404		Field:    field,
 3405		Args:     nil,
 3406		IsMethod: true,
 3407	}
 3408
 3409	ctx = graphql.WithFieldContext(ctx, fc)
 3410	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3411		ctx = rctx // use context from middleware stack in children
 3412		return obj.MessageIsEmpty(), nil
 3413	})
 3414	if err != nil {
 3415		ec.Error(ctx, err)
 3416		return graphql.Null
 3417	}
 3418	if resTmp == nil {
 3419		if !graphql.HasFieldError(ctx, fc) {
 3420			ec.Errorf(ctx, "must not be null")
 3421		}
 3422		return graphql.Null
 3423	}
 3424	res := resTmp.(bool)
 3425	fc.Result = res
 3426	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3427}
 3428
 3429func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3430	defer func() {
 3431		if r := recover(); r != nil {
 3432			ec.Error(ctx, ec.Recover(ctx, r))
 3433			ret = graphql.Null
 3434		}
 3435	}()
 3436	fc := &graphql.FieldContext{
 3437		Object:   "AddCommentTimelineItem",
 3438		Field:    field,
 3439		Args:     nil,
 3440		IsMethod: false,
 3441	}
 3442
 3443	ctx = graphql.WithFieldContext(ctx, fc)
 3444	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3445		ctx = rctx // use context from middleware stack in children
 3446		return obj.Files, nil
 3447	})
 3448	if err != nil {
 3449		ec.Error(ctx, err)
 3450		return graphql.Null
 3451	}
 3452	if resTmp == nil {
 3453		if !graphql.HasFieldError(ctx, fc) {
 3454			ec.Errorf(ctx, "must not be null")
 3455		}
 3456		return graphql.Null
 3457	}
 3458	res := resTmp.([]git.Hash)
 3459	fc.Result = res
 3460	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 3461}
 3462
 3463func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3464	defer func() {
 3465		if r := recover(); r != nil {
 3466			ec.Error(ctx, ec.Recover(ctx, r))
 3467			ret = graphql.Null
 3468		}
 3469	}()
 3470	fc := &graphql.FieldContext{
 3471		Object:   "AddCommentTimelineItem",
 3472		Field:    field,
 3473		Args:     nil,
 3474		IsMethod: true,
 3475	}
 3476
 3477	ctx = graphql.WithFieldContext(ctx, fc)
 3478	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3479		ctx = rctx // use context from middleware stack in children
 3480		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3481	})
 3482	if err != nil {
 3483		ec.Error(ctx, err)
 3484		return graphql.Null
 3485	}
 3486	if resTmp == nil {
 3487		if !graphql.HasFieldError(ctx, fc) {
 3488			ec.Errorf(ctx, "must not be null")
 3489		}
 3490		return graphql.Null
 3491	}
 3492	res := resTmp.(*time.Time)
 3493	fc.Result = res
 3494	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3495}
 3496
 3497func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3498	defer func() {
 3499		if r := recover(); r != nil {
 3500			ec.Error(ctx, ec.Recover(ctx, r))
 3501			ret = graphql.Null
 3502		}
 3503	}()
 3504	fc := &graphql.FieldContext{
 3505		Object:   "AddCommentTimelineItem",
 3506		Field:    field,
 3507		Args:     nil,
 3508		IsMethod: true,
 3509	}
 3510
 3511	ctx = graphql.WithFieldContext(ctx, fc)
 3512	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3513		ctx = rctx // use context from middleware stack in children
 3514		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3515	})
 3516	if err != nil {
 3517		ec.Error(ctx, err)
 3518		return graphql.Null
 3519	}
 3520	if resTmp == nil {
 3521		if !graphql.HasFieldError(ctx, fc) {
 3522			ec.Errorf(ctx, "must not be null")
 3523		}
 3524		return graphql.Null
 3525	}
 3526	res := resTmp.(*time.Time)
 3527	fc.Result = res
 3528	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3529}
 3530
 3531func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3532	defer func() {
 3533		if r := recover(); r != nil {
 3534			ec.Error(ctx, ec.Recover(ctx, r))
 3535			ret = graphql.Null
 3536		}
 3537	}()
 3538	fc := &graphql.FieldContext{
 3539		Object:   "AddCommentTimelineItem",
 3540		Field:    field,
 3541		Args:     nil,
 3542		IsMethod: true,
 3543	}
 3544
 3545	ctx = graphql.WithFieldContext(ctx, fc)
 3546	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3547		ctx = rctx // use context from middleware stack in children
 3548		return obj.Edited(), nil
 3549	})
 3550	if err != nil {
 3551		ec.Error(ctx, err)
 3552		return graphql.Null
 3553	}
 3554	if resTmp == nil {
 3555		if !graphql.HasFieldError(ctx, fc) {
 3556			ec.Errorf(ctx, "must not be null")
 3557		}
 3558		return graphql.Null
 3559	}
 3560	res := resTmp.(bool)
 3561	fc.Result = res
 3562	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3563}
 3564
 3565func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3566	defer func() {
 3567		if r := recover(); r != nil {
 3568			ec.Error(ctx, ec.Recover(ctx, r))
 3569			ret = graphql.Null
 3570		}
 3571	}()
 3572	fc := &graphql.FieldContext{
 3573		Object:   "AddCommentTimelineItem",
 3574		Field:    field,
 3575		Args:     nil,
 3576		IsMethod: false,
 3577	}
 3578
 3579	ctx = graphql.WithFieldContext(ctx, fc)
 3580	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3581		ctx = rctx // use context from middleware stack in children
 3582		return obj.History, nil
 3583	})
 3584	if err != nil {
 3585		ec.Error(ctx, err)
 3586		return graphql.Null
 3587	}
 3588	if resTmp == nil {
 3589		if !graphql.HasFieldError(ctx, fc) {
 3590			ec.Errorf(ctx, "must not be null")
 3591		}
 3592		return graphql.Null
 3593	}
 3594	res := resTmp.([]bug.CommentHistoryStep)
 3595	fc.Result = res
 3596	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 3597}
 3598
 3599func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3600	defer func() {
 3601		if r := recover(); r != nil {
 3602			ec.Error(ctx, ec.Recover(ctx, r))
 3603			ret = graphql.Null
 3604		}
 3605	}()
 3606	fc := &graphql.FieldContext{
 3607		Object:   "Bug",
 3608		Field:    field,
 3609		Args:     nil,
 3610		IsMethod: true,
 3611	}
 3612
 3613	ctx = graphql.WithFieldContext(ctx, fc)
 3614	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3615		ctx = rctx // use context from middleware stack in children
 3616		return ec.resolvers.Bug().ID(rctx, obj)
 3617	})
 3618	if err != nil {
 3619		ec.Error(ctx, err)
 3620		return graphql.Null
 3621	}
 3622	if resTmp == nil {
 3623		if !graphql.HasFieldError(ctx, fc) {
 3624			ec.Errorf(ctx, "must not be null")
 3625		}
 3626		return graphql.Null
 3627	}
 3628	res := resTmp.(string)
 3629	fc.Result = res
 3630	return ec.marshalNString2string(ctx, field.Selections, res)
 3631}
 3632
 3633func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3634	defer func() {
 3635		if r := recover(); r != nil {
 3636			ec.Error(ctx, ec.Recover(ctx, r))
 3637			ret = graphql.Null
 3638		}
 3639	}()
 3640	fc := &graphql.FieldContext{
 3641		Object:   "Bug",
 3642		Field:    field,
 3643		Args:     nil,
 3644		IsMethod: true,
 3645	}
 3646
 3647	ctx = graphql.WithFieldContext(ctx, fc)
 3648	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3649		ctx = rctx // use context from middleware stack in children
 3650		return ec.resolvers.Bug().HumanID(rctx, obj)
 3651	})
 3652	if err != nil {
 3653		ec.Error(ctx, err)
 3654		return graphql.Null
 3655	}
 3656	if resTmp == nil {
 3657		if !graphql.HasFieldError(ctx, fc) {
 3658			ec.Errorf(ctx, "must not be null")
 3659		}
 3660		return graphql.Null
 3661	}
 3662	res := resTmp.(string)
 3663	fc.Result = res
 3664	return ec.marshalNString2string(ctx, field.Selections, res)
 3665}
 3666
 3667func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3668	defer func() {
 3669		if r := recover(); r != nil {
 3670			ec.Error(ctx, ec.Recover(ctx, r))
 3671			ret = graphql.Null
 3672		}
 3673	}()
 3674	fc := &graphql.FieldContext{
 3675		Object:   "Bug",
 3676		Field:    field,
 3677		Args:     nil,
 3678		IsMethod: true,
 3679	}
 3680
 3681	ctx = graphql.WithFieldContext(ctx, fc)
 3682	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3683		ctx = rctx // use context from middleware stack in children
 3684		return ec.resolvers.Bug().Status(rctx, obj)
 3685	})
 3686	if err != nil {
 3687		ec.Error(ctx, err)
 3688		return graphql.Null
 3689	}
 3690	if resTmp == nil {
 3691		if !graphql.HasFieldError(ctx, fc) {
 3692			ec.Errorf(ctx, "must not be null")
 3693		}
 3694		return graphql.Null
 3695	}
 3696	res := resTmp.(models.Status)
 3697	fc.Result = res
 3698	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3699}
 3700
 3701func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3702	defer func() {
 3703		if r := recover(); r != nil {
 3704			ec.Error(ctx, ec.Recover(ctx, r))
 3705			ret = graphql.Null
 3706		}
 3707	}()
 3708	fc := &graphql.FieldContext{
 3709		Object:   "Bug",
 3710		Field:    field,
 3711		Args:     nil,
 3712		IsMethod: true,
 3713	}
 3714
 3715	ctx = graphql.WithFieldContext(ctx, fc)
 3716	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3717		ctx = rctx // use context from middleware stack in children
 3718		return obj.Title(), nil
 3719	})
 3720	if err != nil {
 3721		ec.Error(ctx, err)
 3722		return graphql.Null
 3723	}
 3724	if resTmp == nil {
 3725		if !graphql.HasFieldError(ctx, fc) {
 3726			ec.Errorf(ctx, "must not be null")
 3727		}
 3728		return graphql.Null
 3729	}
 3730	res := resTmp.(string)
 3731	fc.Result = res
 3732	return ec.marshalNString2string(ctx, field.Selections, res)
 3733}
 3734
 3735func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3736	defer func() {
 3737		if r := recover(); r != nil {
 3738			ec.Error(ctx, ec.Recover(ctx, r))
 3739			ret = graphql.Null
 3740		}
 3741	}()
 3742	fc := &graphql.FieldContext{
 3743		Object:   "Bug",
 3744		Field:    field,
 3745		Args:     nil,
 3746		IsMethod: true,
 3747	}
 3748
 3749	ctx = graphql.WithFieldContext(ctx, fc)
 3750	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3751		ctx = rctx // use context from middleware stack in children
 3752		return obj.Labels(), nil
 3753	})
 3754	if err != nil {
 3755		ec.Error(ctx, err)
 3756		return graphql.Null
 3757	}
 3758	if resTmp == nil {
 3759		if !graphql.HasFieldError(ctx, fc) {
 3760			ec.Errorf(ctx, "must not be null")
 3761		}
 3762		return graphql.Null
 3763	}
 3764	res := resTmp.([]bug.Label)
 3765	fc.Result = res
 3766	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 3767}
 3768
 3769func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3770	defer func() {
 3771		if r := recover(); r != nil {
 3772			ec.Error(ctx, ec.Recover(ctx, r))
 3773			ret = graphql.Null
 3774		}
 3775	}()
 3776	fc := &graphql.FieldContext{
 3777		Object:   "Bug",
 3778		Field:    field,
 3779		Args:     nil,
 3780		IsMethod: true,
 3781	}
 3782
 3783	ctx = graphql.WithFieldContext(ctx, fc)
 3784	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3785		ctx = rctx // use context from middleware stack in children
 3786		return obj.Author()
 3787	})
 3788	if err != nil {
 3789		ec.Error(ctx, err)
 3790		return graphql.Null
 3791	}
 3792	if resTmp == nil {
 3793		if !graphql.HasFieldError(ctx, fc) {
 3794			ec.Errorf(ctx, "must not be null")
 3795		}
 3796		return graphql.Null
 3797	}
 3798	res := resTmp.(models.IdentityWrapper)
 3799	fc.Result = res
 3800	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 3801}
 3802
 3803func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3804	defer func() {
 3805		if r := recover(); r != nil {
 3806			ec.Error(ctx, ec.Recover(ctx, r))
 3807			ret = graphql.Null
 3808		}
 3809	}()
 3810	fc := &graphql.FieldContext{
 3811		Object:   "Bug",
 3812		Field:    field,
 3813		Args:     nil,
 3814		IsMethod: true,
 3815	}
 3816
 3817	ctx = graphql.WithFieldContext(ctx, fc)
 3818	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3819		ctx = rctx // use context from middleware stack in children
 3820		return obj.CreatedAt(), nil
 3821	})
 3822	if err != nil {
 3823		ec.Error(ctx, err)
 3824		return graphql.Null
 3825	}
 3826	if resTmp == nil {
 3827		if !graphql.HasFieldError(ctx, fc) {
 3828			ec.Errorf(ctx, "must not be null")
 3829		}
 3830		return graphql.Null
 3831	}
 3832	res := resTmp.(time.Time)
 3833	fc.Result = res
 3834	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3835}
 3836
 3837func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3838	defer func() {
 3839		if r := recover(); r != nil {
 3840			ec.Error(ctx, ec.Recover(ctx, r))
 3841			ret = graphql.Null
 3842		}
 3843	}()
 3844	fc := &graphql.FieldContext{
 3845		Object:   "Bug",
 3846		Field:    field,
 3847		Args:     nil,
 3848		IsMethod: true,
 3849	}
 3850
 3851	ctx = graphql.WithFieldContext(ctx, fc)
 3852	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3853		ctx = rctx // use context from middleware stack in children
 3854		return obj.LastEdit(), nil
 3855	})
 3856	if err != nil {
 3857		ec.Error(ctx, err)
 3858		return graphql.Null
 3859	}
 3860	if resTmp == nil {
 3861		if !graphql.HasFieldError(ctx, fc) {
 3862			ec.Errorf(ctx, "must not be null")
 3863		}
 3864		return graphql.Null
 3865	}
 3866	res := resTmp.(time.Time)
 3867	fc.Result = res
 3868	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3869}
 3870
 3871func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3872	defer func() {
 3873		if r := recover(); r != nil {
 3874			ec.Error(ctx, ec.Recover(ctx, r))
 3875			ret = graphql.Null
 3876		}
 3877	}()
 3878	fc := &graphql.FieldContext{
 3879		Object:   "Bug",
 3880		Field:    field,
 3881		Args:     nil,
 3882		IsMethod: true,
 3883	}
 3884
 3885	ctx = graphql.WithFieldContext(ctx, fc)
 3886	rawArgs := field.ArgumentMap(ec.Variables)
 3887	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3888	if err != nil {
 3889		ec.Error(ctx, err)
 3890		return graphql.Null
 3891	}
 3892	fc.Args = args
 3893	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3894		ctx = rctx // use context from middleware stack in children
 3895		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3896	})
 3897	if err != nil {
 3898		ec.Error(ctx, err)
 3899		return graphql.Null
 3900	}
 3901	if resTmp == nil {
 3902		if !graphql.HasFieldError(ctx, fc) {
 3903			ec.Errorf(ctx, "must not be null")
 3904		}
 3905		return graphql.Null
 3906	}
 3907	res := resTmp.(*models.IdentityConnection)
 3908	fc.Result = res
 3909	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3910}
 3911
 3912func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3913	defer func() {
 3914		if r := recover(); r != nil {
 3915			ec.Error(ctx, ec.Recover(ctx, r))
 3916			ret = graphql.Null
 3917		}
 3918	}()
 3919	fc := &graphql.FieldContext{
 3920		Object:   "Bug",
 3921		Field:    field,
 3922		Args:     nil,
 3923		IsMethod: true,
 3924	}
 3925
 3926	ctx = graphql.WithFieldContext(ctx, fc)
 3927	rawArgs := field.ArgumentMap(ec.Variables)
 3928	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3929	if err != nil {
 3930		ec.Error(ctx, err)
 3931		return graphql.Null
 3932	}
 3933	fc.Args = args
 3934	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3935		ctx = rctx // use context from middleware stack in children
 3936		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3937	})
 3938	if err != nil {
 3939		ec.Error(ctx, err)
 3940		return graphql.Null
 3941	}
 3942	if resTmp == nil {
 3943		if !graphql.HasFieldError(ctx, fc) {
 3944			ec.Errorf(ctx, "must not be null")
 3945		}
 3946		return graphql.Null
 3947	}
 3948	res := resTmp.(*models.IdentityConnection)
 3949	fc.Result = res
 3950	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3951}
 3952
 3953func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3954	defer func() {
 3955		if r := recover(); r != nil {
 3956			ec.Error(ctx, ec.Recover(ctx, r))
 3957			ret = graphql.Null
 3958		}
 3959	}()
 3960	fc := &graphql.FieldContext{
 3961		Object:   "Bug",
 3962		Field:    field,
 3963		Args:     nil,
 3964		IsMethod: true,
 3965	}
 3966
 3967	ctx = graphql.WithFieldContext(ctx, fc)
 3968	rawArgs := field.ArgumentMap(ec.Variables)
 3969	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3970	if err != nil {
 3971		ec.Error(ctx, err)
 3972		return graphql.Null
 3973	}
 3974	fc.Args = args
 3975	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3976		ctx = rctx // use context from middleware stack in children
 3977		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3978	})
 3979	if err != nil {
 3980		ec.Error(ctx, err)
 3981		return graphql.Null
 3982	}
 3983	if resTmp == nil {
 3984		if !graphql.HasFieldError(ctx, fc) {
 3985			ec.Errorf(ctx, "must not be null")
 3986		}
 3987		return graphql.Null
 3988	}
 3989	res := resTmp.(*models.CommentConnection)
 3990	fc.Result = res
 3991	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3992}
 3993
 3994func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 3995	defer func() {
 3996		if r := recover(); r != nil {
 3997			ec.Error(ctx, ec.Recover(ctx, r))
 3998			ret = graphql.Null
 3999		}
 4000	}()
 4001	fc := &graphql.FieldContext{
 4002		Object:   "Bug",
 4003		Field:    field,
 4004		Args:     nil,
 4005		IsMethod: true,
 4006	}
 4007
 4008	ctx = graphql.WithFieldContext(ctx, fc)
 4009	rawArgs := field.ArgumentMap(ec.Variables)
 4010	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 4011	if err != nil {
 4012		ec.Error(ctx, err)
 4013		return graphql.Null
 4014	}
 4015	fc.Args = args
 4016	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4017		ctx = rctx // use context from middleware stack in children
 4018		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4019	})
 4020	if err != nil {
 4021		ec.Error(ctx, err)
 4022		return graphql.Null
 4023	}
 4024	if resTmp == nil {
 4025		if !graphql.HasFieldError(ctx, fc) {
 4026			ec.Errorf(ctx, "must not be null")
 4027		}
 4028		return graphql.Null
 4029	}
 4030	res := resTmp.(*models.TimelineItemConnection)
 4031	fc.Result = res
 4032	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 4033}
 4034
 4035func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 4036	defer func() {
 4037		if r := recover(); r != nil {
 4038			ec.Error(ctx, ec.Recover(ctx, r))
 4039			ret = graphql.Null
 4040		}
 4041	}()
 4042	fc := &graphql.FieldContext{
 4043		Object:   "Bug",
 4044		Field:    field,
 4045		Args:     nil,
 4046		IsMethod: true,
 4047	}
 4048
 4049	ctx = graphql.WithFieldContext(ctx, fc)
 4050	rawArgs := field.ArgumentMap(ec.Variables)
 4051	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 4052	if err != nil {
 4053		ec.Error(ctx, err)
 4054		return graphql.Null
 4055	}
 4056	fc.Args = args
 4057	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4058		ctx = rctx // use context from middleware stack in children
 4059		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4060	})
 4061	if err != nil {
 4062		ec.Error(ctx, err)
 4063		return graphql.Null
 4064	}
 4065	if resTmp == nil {
 4066		if !graphql.HasFieldError(ctx, fc) {
 4067			ec.Errorf(ctx, "must not be null")
 4068		}
 4069		return graphql.Null
 4070	}
 4071	res := resTmp.(*models.OperationConnection)
 4072	fc.Result = res
 4073	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 4074}
 4075
 4076func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4077	defer func() {
 4078		if r := recover(); r != nil {
 4079			ec.Error(ctx, ec.Recover(ctx, r))
 4080			ret = graphql.Null
 4081		}
 4082	}()
 4083	fc := &graphql.FieldContext{
 4084		Object:   "BugConnection",
 4085		Field:    field,
 4086		Args:     nil,
 4087		IsMethod: false,
 4088	}
 4089
 4090	ctx = graphql.WithFieldContext(ctx, fc)
 4091	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4092		ctx = rctx // use context from middleware stack in children
 4093		return obj.Edges, nil
 4094	})
 4095	if err != nil {
 4096		ec.Error(ctx, err)
 4097		return graphql.Null
 4098	}
 4099	if resTmp == nil {
 4100		if !graphql.HasFieldError(ctx, fc) {
 4101			ec.Errorf(ctx, "must not be null")
 4102		}
 4103		return graphql.Null
 4104	}
 4105	res := resTmp.([]*models.BugEdge)
 4106	fc.Result = res
 4107	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
 4108}
 4109
 4110func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4111	defer func() {
 4112		if r := recover(); r != nil {
 4113			ec.Error(ctx, ec.Recover(ctx, r))
 4114			ret = graphql.Null
 4115		}
 4116	}()
 4117	fc := &graphql.FieldContext{
 4118		Object:   "BugConnection",
 4119		Field:    field,
 4120		Args:     nil,
 4121		IsMethod: false,
 4122	}
 4123
 4124	ctx = graphql.WithFieldContext(ctx, fc)
 4125	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4126		ctx = rctx // use context from middleware stack in children
 4127		return obj.Nodes, nil
 4128	})
 4129	if err != nil {
 4130		ec.Error(ctx, err)
 4131		return graphql.Null
 4132	}
 4133	if resTmp == nil {
 4134		if !graphql.HasFieldError(ctx, fc) {
 4135			ec.Errorf(ctx, "must not be null")
 4136		}
 4137		return graphql.Null
 4138	}
 4139	res := resTmp.([]models.BugWrapper)
 4140	fc.Result = res
 4141	return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
 4142}
 4143
 4144func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4145	defer func() {
 4146		if r := recover(); r != nil {
 4147			ec.Error(ctx, ec.Recover(ctx, r))
 4148			ret = graphql.Null
 4149		}
 4150	}()
 4151	fc := &graphql.FieldContext{
 4152		Object:   "BugConnection",
 4153		Field:    field,
 4154		Args:     nil,
 4155		IsMethod: false,
 4156	}
 4157
 4158	ctx = graphql.WithFieldContext(ctx, fc)
 4159	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4160		ctx = rctx // use context from middleware stack in children
 4161		return obj.PageInfo, nil
 4162	})
 4163	if err != nil {
 4164		ec.Error(ctx, err)
 4165		return graphql.Null
 4166	}
 4167	if resTmp == nil {
 4168		if !graphql.HasFieldError(ctx, fc) {
 4169			ec.Errorf(ctx, "must not be null")
 4170		}
 4171		return graphql.Null
 4172	}
 4173	res := resTmp.(*models.PageInfo)
 4174	fc.Result = res
 4175	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4176}
 4177
 4178func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4179	defer func() {
 4180		if r := recover(); r != nil {
 4181			ec.Error(ctx, ec.Recover(ctx, r))
 4182			ret = graphql.Null
 4183		}
 4184	}()
 4185	fc := &graphql.FieldContext{
 4186		Object:   "BugConnection",
 4187		Field:    field,
 4188		Args:     nil,
 4189		IsMethod: false,
 4190	}
 4191
 4192	ctx = graphql.WithFieldContext(ctx, fc)
 4193	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4194		ctx = rctx // use context from middleware stack in children
 4195		return obj.TotalCount, nil
 4196	})
 4197	if err != nil {
 4198		ec.Error(ctx, err)
 4199		return graphql.Null
 4200	}
 4201	if resTmp == nil {
 4202		if !graphql.HasFieldError(ctx, fc) {
 4203			ec.Errorf(ctx, "must not be null")
 4204		}
 4205		return graphql.Null
 4206	}
 4207	res := resTmp.(int)
 4208	fc.Result = res
 4209	return ec.marshalNInt2int(ctx, field.Selections, res)
 4210}
 4211
 4212func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4213	defer func() {
 4214		if r := recover(); r != nil {
 4215			ec.Error(ctx, ec.Recover(ctx, r))
 4216			ret = graphql.Null
 4217		}
 4218	}()
 4219	fc := &graphql.FieldContext{
 4220		Object:   "BugEdge",
 4221		Field:    field,
 4222		Args:     nil,
 4223		IsMethod: false,
 4224	}
 4225
 4226	ctx = graphql.WithFieldContext(ctx, fc)
 4227	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4228		ctx = rctx // use context from middleware stack in children
 4229		return obj.Cursor, nil
 4230	})
 4231	if err != nil {
 4232		ec.Error(ctx, err)
 4233		return graphql.Null
 4234	}
 4235	if resTmp == nil {
 4236		if !graphql.HasFieldError(ctx, fc) {
 4237			ec.Errorf(ctx, "must not be null")
 4238		}
 4239		return graphql.Null
 4240	}
 4241	res := resTmp.(string)
 4242	fc.Result = res
 4243	return ec.marshalNString2string(ctx, field.Selections, res)
 4244}
 4245
 4246func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4247	defer func() {
 4248		if r := recover(); r != nil {
 4249			ec.Error(ctx, ec.Recover(ctx, r))
 4250			ret = graphql.Null
 4251		}
 4252	}()
 4253	fc := &graphql.FieldContext{
 4254		Object:   "BugEdge",
 4255		Field:    field,
 4256		Args:     nil,
 4257		IsMethod: false,
 4258	}
 4259
 4260	ctx = graphql.WithFieldContext(ctx, fc)
 4261	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4262		ctx = rctx // use context from middleware stack in children
 4263		return obj.Node, nil
 4264	})
 4265	if err != nil {
 4266		ec.Error(ctx, err)
 4267		return graphql.Null
 4268	}
 4269	if resTmp == nil {
 4270		if !graphql.HasFieldError(ctx, fc) {
 4271			ec.Errorf(ctx, "must not be null")
 4272		}
 4273		return graphql.Null
 4274	}
 4275	res := resTmp.(models.BugWrapper)
 4276	fc.Result = res
 4277	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4278}
 4279
 4280func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4281	defer func() {
 4282		if r := recover(); r != nil {
 4283			ec.Error(ctx, ec.Recover(ctx, r))
 4284			ret = graphql.Null
 4285		}
 4286	}()
 4287	fc := &graphql.FieldContext{
 4288		Object:   "ChangeLabelPayload",
 4289		Field:    field,
 4290		Args:     nil,
 4291		IsMethod: false,
 4292	}
 4293
 4294	ctx = graphql.WithFieldContext(ctx, fc)
 4295	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4296		ctx = rctx // use context from middleware stack in children
 4297		return obj.ClientMutationID, nil
 4298	})
 4299	if err != nil {
 4300		ec.Error(ctx, err)
 4301		return graphql.Null
 4302	}
 4303	if resTmp == nil {
 4304		return graphql.Null
 4305	}
 4306	res := resTmp.(*string)
 4307	fc.Result = res
 4308	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4309}
 4310
 4311func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4312	defer func() {
 4313		if r := recover(); r != nil {
 4314			ec.Error(ctx, ec.Recover(ctx, r))
 4315			ret = graphql.Null
 4316		}
 4317	}()
 4318	fc := &graphql.FieldContext{
 4319		Object:   "ChangeLabelPayload",
 4320		Field:    field,
 4321		Args:     nil,
 4322		IsMethod: false,
 4323	}
 4324
 4325	ctx = graphql.WithFieldContext(ctx, fc)
 4326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4327		ctx = rctx // use context from middleware stack in children
 4328		return obj.Bug, nil
 4329	})
 4330	if err != nil {
 4331		ec.Error(ctx, err)
 4332		return graphql.Null
 4333	}
 4334	if resTmp == nil {
 4335		if !graphql.HasFieldError(ctx, fc) {
 4336			ec.Errorf(ctx, "must not be null")
 4337		}
 4338		return graphql.Null
 4339	}
 4340	res := resTmp.(models.BugWrapper)
 4341	fc.Result = res
 4342	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4343}
 4344
 4345func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4346	defer func() {
 4347		if r := recover(); r != nil {
 4348			ec.Error(ctx, ec.Recover(ctx, r))
 4349			ret = graphql.Null
 4350		}
 4351	}()
 4352	fc := &graphql.FieldContext{
 4353		Object:   "ChangeLabelPayload",
 4354		Field:    field,
 4355		Args:     nil,
 4356		IsMethod: false,
 4357	}
 4358
 4359	ctx = graphql.WithFieldContext(ctx, fc)
 4360	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4361		ctx = rctx // use context from middleware stack in children
 4362		return obj.Operation, nil
 4363	})
 4364	if err != nil {
 4365		ec.Error(ctx, err)
 4366		return graphql.Null
 4367	}
 4368	if resTmp == nil {
 4369		if !graphql.HasFieldError(ctx, fc) {
 4370			ec.Errorf(ctx, "must not be null")
 4371		}
 4372		return graphql.Null
 4373	}
 4374	res := resTmp.(*bug.LabelChangeOperation)
 4375	fc.Result = res
 4376	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4377}
 4378
 4379func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4380	defer func() {
 4381		if r := recover(); r != nil {
 4382			ec.Error(ctx, ec.Recover(ctx, r))
 4383			ret = graphql.Null
 4384		}
 4385	}()
 4386	fc := &graphql.FieldContext{
 4387		Object:   "ChangeLabelPayload",
 4388		Field:    field,
 4389		Args:     nil,
 4390		IsMethod: false,
 4391	}
 4392
 4393	ctx = graphql.WithFieldContext(ctx, fc)
 4394	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4395		ctx = rctx // use context from middleware stack in children
 4396		return obj.Results, nil
 4397	})
 4398	if err != nil {
 4399		ec.Error(ctx, err)
 4400		return graphql.Null
 4401	}
 4402	if resTmp == nil {
 4403		if !graphql.HasFieldError(ctx, fc) {
 4404			ec.Errorf(ctx, "must not be null")
 4405		}
 4406		return graphql.Null
 4407	}
 4408	res := resTmp.([]*bug.LabelChangeResult)
 4409	fc.Result = res
 4410	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4411}
 4412
 4413func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4414	defer func() {
 4415		if r := recover(); r != nil {
 4416			ec.Error(ctx, ec.Recover(ctx, r))
 4417			ret = graphql.Null
 4418		}
 4419	}()
 4420	fc := &graphql.FieldContext{
 4421		Object:   "CloseBugPayload",
 4422		Field:    field,
 4423		Args:     nil,
 4424		IsMethod: false,
 4425	}
 4426
 4427	ctx = graphql.WithFieldContext(ctx, fc)
 4428	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4429		ctx = rctx // use context from middleware stack in children
 4430		return obj.ClientMutationID, nil
 4431	})
 4432	if err != nil {
 4433		ec.Error(ctx, err)
 4434		return graphql.Null
 4435	}
 4436	if resTmp == nil {
 4437		return graphql.Null
 4438	}
 4439	res := resTmp.(*string)
 4440	fc.Result = res
 4441	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4442}
 4443
 4444func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4445	defer func() {
 4446		if r := recover(); r != nil {
 4447			ec.Error(ctx, ec.Recover(ctx, r))
 4448			ret = graphql.Null
 4449		}
 4450	}()
 4451	fc := &graphql.FieldContext{
 4452		Object:   "CloseBugPayload",
 4453		Field:    field,
 4454		Args:     nil,
 4455		IsMethod: false,
 4456	}
 4457
 4458	ctx = graphql.WithFieldContext(ctx, fc)
 4459	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4460		ctx = rctx // use context from middleware stack in children
 4461		return obj.Bug, nil
 4462	})
 4463	if err != nil {
 4464		ec.Error(ctx, err)
 4465		return graphql.Null
 4466	}
 4467	if resTmp == nil {
 4468		if !graphql.HasFieldError(ctx, fc) {
 4469			ec.Errorf(ctx, "must not be null")
 4470		}
 4471		return graphql.Null
 4472	}
 4473	res := resTmp.(models.BugWrapper)
 4474	fc.Result = res
 4475	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 4476}
 4477
 4478func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4479	defer func() {
 4480		if r := recover(); r != nil {
 4481			ec.Error(ctx, ec.Recover(ctx, r))
 4482			ret = graphql.Null
 4483		}
 4484	}()
 4485	fc := &graphql.FieldContext{
 4486		Object:   "CloseBugPayload",
 4487		Field:    field,
 4488		Args:     nil,
 4489		IsMethod: false,
 4490	}
 4491
 4492	ctx = graphql.WithFieldContext(ctx, fc)
 4493	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4494		ctx = rctx // use context from middleware stack in children
 4495		return obj.Operation, nil
 4496	})
 4497	if err != nil {
 4498		ec.Error(ctx, err)
 4499		return graphql.Null
 4500	}
 4501	if resTmp == nil {
 4502		if !graphql.HasFieldError(ctx, fc) {
 4503			ec.Errorf(ctx, "must not be null")
 4504		}
 4505		return graphql.Null
 4506	}
 4507	res := resTmp.(*bug.SetStatusOperation)
 4508	fc.Result = res
 4509	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4510}
 4511
 4512func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4513	defer func() {
 4514		if r := recover(); r != nil {
 4515			ec.Error(ctx, ec.Recover(ctx, r))
 4516			ret = graphql.Null
 4517		}
 4518	}()
 4519	fc := &graphql.FieldContext{
 4520		Object:   "Color",
 4521		Field:    field,
 4522		Args:     nil,
 4523		IsMethod: true,
 4524	}
 4525
 4526	ctx = graphql.WithFieldContext(ctx, fc)
 4527	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4528		ctx = rctx // use context from middleware stack in children
 4529		return ec.resolvers.Color().R(rctx, obj)
 4530	})
 4531	if err != nil {
 4532		ec.Error(ctx, err)
 4533		return graphql.Null
 4534	}
 4535	if resTmp == nil {
 4536		if !graphql.HasFieldError(ctx, fc) {
 4537			ec.Errorf(ctx, "must not be null")
 4538		}
 4539		return graphql.Null
 4540	}
 4541	res := resTmp.(int)
 4542	fc.Result = res
 4543	return ec.marshalNInt2int(ctx, field.Selections, res)
 4544}
 4545
 4546func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4547	defer func() {
 4548		if r := recover(); r != nil {
 4549			ec.Error(ctx, ec.Recover(ctx, r))
 4550			ret = graphql.Null
 4551		}
 4552	}()
 4553	fc := &graphql.FieldContext{
 4554		Object:   "Color",
 4555		Field:    field,
 4556		Args:     nil,
 4557		IsMethod: true,
 4558	}
 4559
 4560	ctx = graphql.WithFieldContext(ctx, fc)
 4561	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4562		ctx = rctx // use context from middleware stack in children
 4563		return ec.resolvers.Color().G(rctx, obj)
 4564	})
 4565	if err != nil {
 4566		ec.Error(ctx, err)
 4567		return graphql.Null
 4568	}
 4569	if resTmp == nil {
 4570		if !graphql.HasFieldError(ctx, fc) {
 4571			ec.Errorf(ctx, "must not be null")
 4572		}
 4573		return graphql.Null
 4574	}
 4575	res := resTmp.(int)
 4576	fc.Result = res
 4577	return ec.marshalNInt2int(ctx, field.Selections, res)
 4578}
 4579
 4580func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4581	defer func() {
 4582		if r := recover(); r != nil {
 4583			ec.Error(ctx, ec.Recover(ctx, r))
 4584			ret = graphql.Null
 4585		}
 4586	}()
 4587	fc := &graphql.FieldContext{
 4588		Object:   "Color",
 4589		Field:    field,
 4590		Args:     nil,
 4591		IsMethod: true,
 4592	}
 4593
 4594	ctx = graphql.WithFieldContext(ctx, fc)
 4595	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4596		ctx = rctx // use context from middleware stack in children
 4597		return ec.resolvers.Color().B(rctx, obj)
 4598	})
 4599	if err != nil {
 4600		ec.Error(ctx, err)
 4601		return graphql.Null
 4602	}
 4603	if resTmp == nil {
 4604		if !graphql.HasFieldError(ctx, fc) {
 4605			ec.Errorf(ctx, "must not be null")
 4606		}
 4607		return graphql.Null
 4608	}
 4609	res := resTmp.(int)
 4610	fc.Result = res
 4611	return ec.marshalNInt2int(ctx, field.Selections, res)
 4612}
 4613
 4614func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4615	defer func() {
 4616		if r := recover(); r != nil {
 4617			ec.Error(ctx, ec.Recover(ctx, r))
 4618			ret = graphql.Null
 4619		}
 4620	}()
 4621	fc := &graphql.FieldContext{
 4622		Object:   "Comment",
 4623		Field:    field,
 4624		Args:     nil,
 4625		IsMethod: true,
 4626	}
 4627
 4628	ctx = graphql.WithFieldContext(ctx, fc)
 4629	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4630		ctx = rctx // use context from middleware stack in children
 4631		return ec.resolvers.Comment().Author(rctx, obj)
 4632	})
 4633	if err != nil {
 4634		ec.Error(ctx, err)
 4635		return graphql.Null
 4636	}
 4637	if resTmp == nil {
 4638		if !graphql.HasFieldError(ctx, fc) {
 4639			ec.Errorf(ctx, "must not be null")
 4640		}
 4641		return graphql.Null
 4642	}
 4643	res := resTmp.(models.IdentityWrapper)
 4644	fc.Result = res
 4645	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 4646}
 4647
 4648func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4649	defer func() {
 4650		if r := recover(); r != nil {
 4651			ec.Error(ctx, ec.Recover(ctx, r))
 4652			ret = graphql.Null
 4653		}
 4654	}()
 4655	fc := &graphql.FieldContext{
 4656		Object:   "Comment",
 4657		Field:    field,
 4658		Args:     nil,
 4659		IsMethod: false,
 4660	}
 4661
 4662	ctx = graphql.WithFieldContext(ctx, fc)
 4663	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4664		ctx = rctx // use context from middleware stack in children
 4665		return obj.Message, nil
 4666	})
 4667	if err != nil {
 4668		ec.Error(ctx, err)
 4669		return graphql.Null
 4670	}
 4671	if resTmp == nil {
 4672		if !graphql.HasFieldError(ctx, fc) {
 4673			ec.Errorf(ctx, "must not be null")
 4674		}
 4675		return graphql.Null
 4676	}
 4677	res := resTmp.(string)
 4678	fc.Result = res
 4679	return ec.marshalNString2string(ctx, field.Selections, res)
 4680}
 4681
 4682func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4683	defer func() {
 4684		if r := recover(); r != nil {
 4685			ec.Error(ctx, ec.Recover(ctx, r))
 4686			ret = graphql.Null
 4687		}
 4688	}()
 4689	fc := &graphql.FieldContext{
 4690		Object:   "Comment",
 4691		Field:    field,
 4692		Args:     nil,
 4693		IsMethod: false,
 4694	}
 4695
 4696	ctx = graphql.WithFieldContext(ctx, fc)
 4697	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4698		ctx = rctx // use context from middleware stack in children
 4699		return obj.Files, nil
 4700	})
 4701	if err != nil {
 4702		ec.Error(ctx, err)
 4703		return graphql.Null
 4704	}
 4705	if resTmp == nil {
 4706		if !graphql.HasFieldError(ctx, fc) {
 4707			ec.Errorf(ctx, "must not be null")
 4708		}
 4709		return graphql.Null
 4710	}
 4711	res := resTmp.([]git.Hash)
 4712	fc.Result = res
 4713	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 4714}
 4715
 4716func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4717	defer func() {
 4718		if r := recover(); r != nil {
 4719			ec.Error(ctx, ec.Recover(ctx, r))
 4720			ret = graphql.Null
 4721		}
 4722	}()
 4723	fc := &graphql.FieldContext{
 4724		Object:   "CommentConnection",
 4725		Field:    field,
 4726		Args:     nil,
 4727		IsMethod: false,
 4728	}
 4729
 4730	ctx = graphql.WithFieldContext(ctx, fc)
 4731	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4732		ctx = rctx // use context from middleware stack in children
 4733		return obj.Edges, nil
 4734	})
 4735	if err != nil {
 4736		ec.Error(ctx, err)
 4737		return graphql.Null
 4738	}
 4739	if resTmp == nil {
 4740		if !graphql.HasFieldError(ctx, fc) {
 4741			ec.Errorf(ctx, "must not be null")
 4742		}
 4743		return graphql.Null
 4744	}
 4745	res := resTmp.([]*models.CommentEdge)
 4746	fc.Result = res
 4747	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
 4748}
 4749
 4750func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4751	defer func() {
 4752		if r := recover(); r != nil {
 4753			ec.Error(ctx, ec.Recover(ctx, r))
 4754			ret = graphql.Null
 4755		}
 4756	}()
 4757	fc := &graphql.FieldContext{
 4758		Object:   "CommentConnection",
 4759		Field:    field,
 4760		Args:     nil,
 4761		IsMethod: false,
 4762	}
 4763
 4764	ctx = graphql.WithFieldContext(ctx, fc)
 4765	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4766		ctx = rctx // use context from middleware stack in children
 4767		return obj.Nodes, nil
 4768	})
 4769	if err != nil {
 4770		ec.Error(ctx, err)
 4771		return graphql.Null
 4772	}
 4773	if resTmp == nil {
 4774		if !graphql.HasFieldError(ctx, fc) {
 4775			ec.Errorf(ctx, "must not be null")
 4776		}
 4777		return graphql.Null
 4778	}
 4779	res := resTmp.([]*bug.Comment)
 4780	fc.Result = res
 4781	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx, field.Selections, res)
 4782}
 4783
 4784func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4785	defer func() {
 4786		if r := recover(); r != nil {
 4787			ec.Error(ctx, ec.Recover(ctx, r))
 4788			ret = graphql.Null
 4789		}
 4790	}()
 4791	fc := &graphql.FieldContext{
 4792		Object:   "CommentConnection",
 4793		Field:    field,
 4794		Args:     nil,
 4795		IsMethod: false,
 4796	}
 4797
 4798	ctx = graphql.WithFieldContext(ctx, fc)
 4799	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4800		ctx = rctx // use context from middleware stack in children
 4801		return obj.PageInfo, nil
 4802	})
 4803	if err != nil {
 4804		ec.Error(ctx, err)
 4805		return graphql.Null
 4806	}
 4807	if resTmp == nil {
 4808		if !graphql.HasFieldError(ctx, fc) {
 4809			ec.Errorf(ctx, "must not be null")
 4810		}
 4811		return graphql.Null
 4812	}
 4813	res := resTmp.(*models.PageInfo)
 4814	fc.Result = res
 4815	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4816}
 4817
 4818func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4819	defer func() {
 4820		if r := recover(); r != nil {
 4821			ec.Error(ctx, ec.Recover(ctx, r))
 4822			ret = graphql.Null
 4823		}
 4824	}()
 4825	fc := &graphql.FieldContext{
 4826		Object:   "CommentConnection",
 4827		Field:    field,
 4828		Args:     nil,
 4829		IsMethod: false,
 4830	}
 4831
 4832	ctx = graphql.WithFieldContext(ctx, fc)
 4833	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4834		ctx = rctx // use context from middleware stack in children
 4835		return obj.TotalCount, nil
 4836	})
 4837	if err != nil {
 4838		ec.Error(ctx, err)
 4839		return graphql.Null
 4840	}
 4841	if resTmp == nil {
 4842		if !graphql.HasFieldError(ctx, fc) {
 4843			ec.Errorf(ctx, "must not be null")
 4844		}
 4845		return graphql.Null
 4846	}
 4847	res := resTmp.(int)
 4848	fc.Result = res
 4849	return ec.marshalNInt2int(ctx, field.Selections, res)
 4850}
 4851
 4852func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4853	defer func() {
 4854		if r := recover(); r != nil {
 4855			ec.Error(ctx, ec.Recover(ctx, r))
 4856			ret = graphql.Null
 4857		}
 4858	}()
 4859	fc := &graphql.FieldContext{
 4860		Object:   "CommentEdge",
 4861		Field:    field,
 4862		Args:     nil,
 4863		IsMethod: false,
 4864	}
 4865
 4866	ctx = graphql.WithFieldContext(ctx, fc)
 4867	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4868		ctx = rctx // use context from middleware stack in children
 4869		return obj.Cursor, nil
 4870	})
 4871	if err != nil {
 4872		ec.Error(ctx, err)
 4873		return graphql.Null
 4874	}
 4875	if resTmp == nil {
 4876		if !graphql.HasFieldError(ctx, fc) {
 4877			ec.Errorf(ctx, "must not be null")
 4878		}
 4879		return graphql.Null
 4880	}
 4881	res := resTmp.(string)
 4882	fc.Result = res
 4883	return ec.marshalNString2string(ctx, field.Selections, res)
 4884}
 4885
 4886func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4887	defer func() {
 4888		if r := recover(); r != nil {
 4889			ec.Error(ctx, ec.Recover(ctx, r))
 4890			ret = graphql.Null
 4891		}
 4892	}()
 4893	fc := &graphql.FieldContext{
 4894		Object:   "CommentEdge",
 4895		Field:    field,
 4896		Args:     nil,
 4897		IsMethod: false,
 4898	}
 4899
 4900	ctx = graphql.WithFieldContext(ctx, fc)
 4901	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4902		ctx = rctx // use context from middleware stack in children
 4903		return obj.Node, nil
 4904	})
 4905	if err != nil {
 4906		ec.Error(ctx, err)
 4907		return graphql.Null
 4908	}
 4909	if resTmp == nil {
 4910		if !graphql.HasFieldError(ctx, fc) {
 4911			ec.Errorf(ctx, "must not be null")
 4912		}
 4913		return graphql.Null
 4914	}
 4915	res := resTmp.(*bug.Comment)
 4916	fc.Result = res
 4917	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4918}
 4919
 4920func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4921	defer func() {
 4922		if r := recover(); r != nil {
 4923			ec.Error(ctx, ec.Recover(ctx, r))
 4924			ret = graphql.Null
 4925		}
 4926	}()
 4927	fc := &graphql.FieldContext{
 4928		Object:   "CommentHistoryStep",
 4929		Field:    field,
 4930		Args:     nil,
 4931		IsMethod: false,
 4932	}
 4933
 4934	ctx = graphql.WithFieldContext(ctx, fc)
 4935	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4936		ctx = rctx // use context from middleware stack in children
 4937		return obj.Message, nil
 4938	})
 4939	if err != nil {
 4940		ec.Error(ctx, err)
 4941		return graphql.Null
 4942	}
 4943	if resTmp == nil {
 4944		if !graphql.HasFieldError(ctx, fc) {
 4945			ec.Errorf(ctx, "must not be null")
 4946		}
 4947		return graphql.Null
 4948	}
 4949	res := resTmp.(string)
 4950	fc.Result = res
 4951	return ec.marshalNString2string(ctx, field.Selections, res)
 4952}
 4953
 4954func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4955	defer func() {
 4956		if r := recover(); r != nil {
 4957			ec.Error(ctx, ec.Recover(ctx, r))
 4958			ret = graphql.Null
 4959		}
 4960	}()
 4961	fc := &graphql.FieldContext{
 4962		Object:   "CommentHistoryStep",
 4963		Field:    field,
 4964		Args:     nil,
 4965		IsMethod: true,
 4966	}
 4967
 4968	ctx = graphql.WithFieldContext(ctx, fc)
 4969	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4970		ctx = rctx // use context from middleware stack in children
 4971		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4972	})
 4973	if err != nil {
 4974		ec.Error(ctx, err)
 4975		return graphql.Null
 4976	}
 4977	if resTmp == nil {
 4978		if !graphql.HasFieldError(ctx, fc) {
 4979			ec.Errorf(ctx, "must not be null")
 4980		}
 4981		return graphql.Null
 4982	}
 4983	res := resTmp.(*time.Time)
 4984	fc.Result = res
 4985	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4986}
 4987
 4988func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 4989	defer func() {
 4990		if r := recover(); r != nil {
 4991			ec.Error(ctx, ec.Recover(ctx, r))
 4992			ret = graphql.Null
 4993		}
 4994	}()
 4995	fc := &graphql.FieldContext{
 4996		Object:   "CommitAsNeededPayload",
 4997		Field:    field,
 4998		Args:     nil,
 4999		IsMethod: false,
 5000	}
 5001
 5002	ctx = graphql.WithFieldContext(ctx, fc)
 5003	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5004		ctx = rctx // use context from middleware stack in children
 5005		return obj.ClientMutationID, nil
 5006	})
 5007	if err != nil {
 5008		ec.Error(ctx, err)
 5009		return graphql.Null
 5010	}
 5011	if resTmp == nil {
 5012		return graphql.Null
 5013	}
 5014	res := resTmp.(*string)
 5015	fc.Result = res
 5016	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5017}
 5018
 5019func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 5020	defer func() {
 5021		if r := recover(); r != nil {
 5022			ec.Error(ctx, ec.Recover(ctx, r))
 5023			ret = graphql.Null
 5024		}
 5025	}()
 5026	fc := &graphql.FieldContext{
 5027		Object:   "CommitAsNeededPayload",
 5028		Field:    field,
 5029		Args:     nil,
 5030		IsMethod: false,
 5031	}
 5032
 5033	ctx = graphql.WithFieldContext(ctx, fc)
 5034	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5035		ctx = rctx // use context from middleware stack in children
 5036		return obj.Bug, nil
 5037	})
 5038	if err != nil {
 5039		ec.Error(ctx, err)
 5040		return graphql.Null
 5041	}
 5042	if resTmp == nil {
 5043		if !graphql.HasFieldError(ctx, fc) {
 5044			ec.Errorf(ctx, "must not be null")
 5045		}
 5046		return graphql.Null
 5047	}
 5048	res := resTmp.(models.BugWrapper)
 5049	fc.Result = res
 5050	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 5051}
 5052
 5053func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5054	defer func() {
 5055		if r := recover(); r != nil {
 5056			ec.Error(ctx, ec.Recover(ctx, r))
 5057			ret = graphql.Null
 5058		}
 5059	}()
 5060	fc := &graphql.FieldContext{
 5061		Object:   "CommitPayload",
 5062		Field:    field,
 5063		Args:     nil,
 5064		IsMethod: false,
 5065	}
 5066
 5067	ctx = graphql.WithFieldContext(ctx, fc)
 5068	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5069		ctx = rctx // use context from middleware stack in children
 5070		return obj.ClientMutationID, nil
 5071	})
 5072	if err != nil {
 5073		ec.Error(ctx, err)
 5074		return graphql.Null
 5075	}
 5076	if resTmp == nil {
 5077		return graphql.Null
 5078	}
 5079	res := resTmp.(*string)
 5080	fc.Result = res
 5081	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5082}
 5083
 5084func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5085	defer func() {
 5086		if r := recover(); r != nil {
 5087			ec.Error(ctx, ec.Recover(ctx, r))
 5088			ret = graphql.Null
 5089		}
 5090	}()
 5091	fc := &graphql.FieldContext{
 5092		Object:   "CommitPayload",
 5093		Field:    field,
 5094		Args:     nil,
 5095		IsMethod: false,
 5096	}
 5097
 5098	ctx = graphql.WithFieldContext(ctx, fc)
 5099	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5100		ctx = rctx // use context from middleware stack in children
 5101		return obj.Bug, nil
 5102	})
 5103	if err != nil {
 5104		ec.Error(ctx, err)
 5105		return graphql.Null
 5106	}
 5107	if resTmp == nil {
 5108		if !graphql.HasFieldError(ctx, fc) {
 5109			ec.Errorf(ctx, "must not be null")
 5110		}
 5111		return graphql.Null
 5112	}
 5113	res := resTmp.(models.BugWrapper)
 5114	fc.Result = res
 5115	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 5116}
 5117
 5118func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5119	defer func() {
 5120		if r := recover(); r != nil {
 5121			ec.Error(ctx, ec.Recover(ctx, r))
 5122			ret = graphql.Null
 5123		}
 5124	}()
 5125	fc := &graphql.FieldContext{
 5126		Object:   "CreateOperation",
 5127		Field:    field,
 5128		Args:     nil,
 5129		IsMethod: true,
 5130	}
 5131
 5132	ctx = graphql.WithFieldContext(ctx, fc)
 5133	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5134		ctx = rctx // use context from middleware stack in children
 5135		return ec.resolvers.CreateOperation().ID(rctx, obj)
 5136	})
 5137	if err != nil {
 5138		ec.Error(ctx, err)
 5139		return graphql.Null
 5140	}
 5141	if resTmp == nil {
 5142		if !graphql.HasFieldError(ctx, fc) {
 5143			ec.Errorf(ctx, "must not be null")
 5144		}
 5145		return graphql.Null
 5146	}
 5147	res := resTmp.(string)
 5148	fc.Result = res
 5149	return ec.marshalNString2string(ctx, field.Selections, res)
 5150}
 5151
 5152func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5153	defer func() {
 5154		if r := recover(); r != nil {
 5155			ec.Error(ctx, ec.Recover(ctx, r))
 5156			ret = graphql.Null
 5157		}
 5158	}()
 5159	fc := &graphql.FieldContext{
 5160		Object:   "CreateOperation",
 5161		Field:    field,
 5162		Args:     nil,
 5163		IsMethod: true,
 5164	}
 5165
 5166	ctx = graphql.WithFieldContext(ctx, fc)
 5167	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5168		ctx = rctx // use context from middleware stack in children
 5169		return ec.resolvers.CreateOperation().Author(rctx, obj)
 5170	})
 5171	if err != nil {
 5172		ec.Error(ctx, err)
 5173		return graphql.Null
 5174	}
 5175	if resTmp == nil {
 5176		if !graphql.HasFieldError(ctx, fc) {
 5177			ec.Errorf(ctx, "must not be null")
 5178		}
 5179		return graphql.Null
 5180	}
 5181	res := resTmp.(models.IdentityWrapper)
 5182	fc.Result = res
 5183	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5184}
 5185
 5186func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5187	defer func() {
 5188		if r := recover(); r != nil {
 5189			ec.Error(ctx, ec.Recover(ctx, r))
 5190			ret = graphql.Null
 5191		}
 5192	}()
 5193	fc := &graphql.FieldContext{
 5194		Object:   "CreateOperation",
 5195		Field:    field,
 5196		Args:     nil,
 5197		IsMethod: true,
 5198	}
 5199
 5200	ctx = graphql.WithFieldContext(ctx, fc)
 5201	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5202		ctx = rctx // use context from middleware stack in children
 5203		return ec.resolvers.CreateOperation().Date(rctx, obj)
 5204	})
 5205	if err != nil {
 5206		ec.Error(ctx, err)
 5207		return graphql.Null
 5208	}
 5209	if resTmp == nil {
 5210		if !graphql.HasFieldError(ctx, fc) {
 5211			ec.Errorf(ctx, "must not be null")
 5212		}
 5213		return graphql.Null
 5214	}
 5215	res := resTmp.(*time.Time)
 5216	fc.Result = res
 5217	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5218}
 5219
 5220func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5221	defer func() {
 5222		if r := recover(); r != nil {
 5223			ec.Error(ctx, ec.Recover(ctx, r))
 5224			ret = graphql.Null
 5225		}
 5226	}()
 5227	fc := &graphql.FieldContext{
 5228		Object:   "CreateOperation",
 5229		Field:    field,
 5230		Args:     nil,
 5231		IsMethod: false,
 5232	}
 5233
 5234	ctx = graphql.WithFieldContext(ctx, fc)
 5235	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5236		ctx = rctx // use context from middleware stack in children
 5237		return obj.Title, nil
 5238	})
 5239	if err != nil {
 5240		ec.Error(ctx, err)
 5241		return graphql.Null
 5242	}
 5243	if resTmp == nil {
 5244		if !graphql.HasFieldError(ctx, fc) {
 5245			ec.Errorf(ctx, "must not be null")
 5246		}
 5247		return graphql.Null
 5248	}
 5249	res := resTmp.(string)
 5250	fc.Result = res
 5251	return ec.marshalNString2string(ctx, field.Selections, res)
 5252}
 5253
 5254func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5255	defer func() {
 5256		if r := recover(); r != nil {
 5257			ec.Error(ctx, ec.Recover(ctx, r))
 5258			ret = graphql.Null
 5259		}
 5260	}()
 5261	fc := &graphql.FieldContext{
 5262		Object:   "CreateOperation",
 5263		Field:    field,
 5264		Args:     nil,
 5265		IsMethod: false,
 5266	}
 5267
 5268	ctx = graphql.WithFieldContext(ctx, fc)
 5269	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5270		ctx = rctx // use context from middleware stack in children
 5271		return obj.Message, nil
 5272	})
 5273	if err != nil {
 5274		ec.Error(ctx, err)
 5275		return graphql.Null
 5276	}
 5277	if resTmp == nil {
 5278		if !graphql.HasFieldError(ctx, fc) {
 5279			ec.Errorf(ctx, "must not be null")
 5280		}
 5281		return graphql.Null
 5282	}
 5283	res := resTmp.(string)
 5284	fc.Result = res
 5285	return ec.marshalNString2string(ctx, field.Selections, res)
 5286}
 5287
 5288func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5289	defer func() {
 5290		if r := recover(); r != nil {
 5291			ec.Error(ctx, ec.Recover(ctx, r))
 5292			ret = graphql.Null
 5293		}
 5294	}()
 5295	fc := &graphql.FieldContext{
 5296		Object:   "CreateOperation",
 5297		Field:    field,
 5298		Args:     nil,
 5299		IsMethod: false,
 5300	}
 5301
 5302	ctx = graphql.WithFieldContext(ctx, fc)
 5303	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5304		ctx = rctx // use context from middleware stack in children
 5305		return obj.Files, nil
 5306	})
 5307	if err != nil {
 5308		ec.Error(ctx, err)
 5309		return graphql.Null
 5310	}
 5311	if resTmp == nil {
 5312		if !graphql.HasFieldError(ctx, fc) {
 5313			ec.Errorf(ctx, "must not be null")
 5314		}
 5315		return graphql.Null
 5316	}
 5317	res := resTmp.([]git.Hash)
 5318	fc.Result = res
 5319	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5320}
 5321
 5322func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5323	defer func() {
 5324		if r := recover(); r != nil {
 5325			ec.Error(ctx, ec.Recover(ctx, r))
 5326			ret = graphql.Null
 5327		}
 5328	}()
 5329	fc := &graphql.FieldContext{
 5330		Object:   "CreateTimelineItem",
 5331		Field:    field,
 5332		Args:     nil,
 5333		IsMethod: true,
 5334	}
 5335
 5336	ctx = graphql.WithFieldContext(ctx, fc)
 5337	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5338		ctx = rctx // use context from middleware stack in children
 5339		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
 5340	})
 5341	if err != nil {
 5342		ec.Error(ctx, err)
 5343		return graphql.Null
 5344	}
 5345	if resTmp == nil {
 5346		if !graphql.HasFieldError(ctx, fc) {
 5347			ec.Errorf(ctx, "must not be null")
 5348		}
 5349		return graphql.Null
 5350	}
 5351	res := resTmp.(string)
 5352	fc.Result = res
 5353	return ec.marshalNString2string(ctx, field.Selections, res)
 5354}
 5355
 5356func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5357	defer func() {
 5358		if r := recover(); r != nil {
 5359			ec.Error(ctx, ec.Recover(ctx, r))
 5360			ret = graphql.Null
 5361		}
 5362	}()
 5363	fc := &graphql.FieldContext{
 5364		Object:   "CreateTimelineItem",
 5365		Field:    field,
 5366		Args:     nil,
 5367		IsMethod: true,
 5368	}
 5369
 5370	ctx = graphql.WithFieldContext(ctx, fc)
 5371	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5372		ctx = rctx // use context from middleware stack in children
 5373		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
 5374	})
 5375	if err != nil {
 5376		ec.Error(ctx, err)
 5377		return graphql.Null
 5378	}
 5379	if resTmp == nil {
 5380		if !graphql.HasFieldError(ctx, fc) {
 5381			ec.Errorf(ctx, "must not be null")
 5382		}
 5383		return graphql.Null
 5384	}
 5385	res := resTmp.(models.IdentityWrapper)
 5386	fc.Result = res
 5387	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5388}
 5389
 5390func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5391	defer func() {
 5392		if r := recover(); r != nil {
 5393			ec.Error(ctx, ec.Recover(ctx, r))
 5394			ret = graphql.Null
 5395		}
 5396	}()
 5397	fc := &graphql.FieldContext{
 5398		Object:   "CreateTimelineItem",
 5399		Field:    field,
 5400		Args:     nil,
 5401		IsMethod: false,
 5402	}
 5403
 5404	ctx = graphql.WithFieldContext(ctx, fc)
 5405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5406		ctx = rctx // use context from middleware stack in children
 5407		return obj.Message, nil
 5408	})
 5409	if err != nil {
 5410		ec.Error(ctx, err)
 5411		return graphql.Null
 5412	}
 5413	if resTmp == nil {
 5414		if !graphql.HasFieldError(ctx, fc) {
 5415			ec.Errorf(ctx, "must not be null")
 5416		}
 5417		return graphql.Null
 5418	}
 5419	res := resTmp.(string)
 5420	fc.Result = res
 5421	return ec.marshalNString2string(ctx, field.Selections, res)
 5422}
 5423
 5424func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5425	defer func() {
 5426		if r := recover(); r != nil {
 5427			ec.Error(ctx, ec.Recover(ctx, r))
 5428			ret = graphql.Null
 5429		}
 5430	}()
 5431	fc := &graphql.FieldContext{
 5432		Object:   "CreateTimelineItem",
 5433		Field:    field,
 5434		Args:     nil,
 5435		IsMethod: true,
 5436	}
 5437
 5438	ctx = graphql.WithFieldContext(ctx, fc)
 5439	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5440		ctx = rctx // use context from middleware stack in children
 5441		return obj.MessageIsEmpty(), nil
 5442	})
 5443	if err != nil {
 5444		ec.Error(ctx, err)
 5445		return graphql.Null
 5446	}
 5447	if resTmp == nil {
 5448		if !graphql.HasFieldError(ctx, fc) {
 5449			ec.Errorf(ctx, "must not be null")
 5450		}
 5451		return graphql.Null
 5452	}
 5453	res := resTmp.(bool)
 5454	fc.Result = res
 5455	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5456}
 5457
 5458func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5459	defer func() {
 5460		if r := recover(); r != nil {
 5461			ec.Error(ctx, ec.Recover(ctx, r))
 5462			ret = graphql.Null
 5463		}
 5464	}()
 5465	fc := &graphql.FieldContext{
 5466		Object:   "CreateTimelineItem",
 5467		Field:    field,
 5468		Args:     nil,
 5469		IsMethod: false,
 5470	}
 5471
 5472	ctx = graphql.WithFieldContext(ctx, fc)
 5473	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5474		ctx = rctx // use context from middleware stack in children
 5475		return obj.Files, nil
 5476	})
 5477	if err != nil {
 5478		ec.Error(ctx, err)
 5479		return graphql.Null
 5480	}
 5481	if resTmp == nil {
 5482		if !graphql.HasFieldError(ctx, fc) {
 5483			ec.Errorf(ctx, "must not be null")
 5484		}
 5485		return graphql.Null
 5486	}
 5487	res := resTmp.([]git.Hash)
 5488	fc.Result = res
 5489	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5490}
 5491
 5492func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5493	defer func() {
 5494		if r := recover(); r != nil {
 5495			ec.Error(ctx, ec.Recover(ctx, r))
 5496			ret = graphql.Null
 5497		}
 5498	}()
 5499	fc := &graphql.FieldContext{
 5500		Object:   "CreateTimelineItem",
 5501		Field:    field,
 5502		Args:     nil,
 5503		IsMethod: true,
 5504	}
 5505
 5506	ctx = graphql.WithFieldContext(ctx, fc)
 5507	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5508		ctx = rctx // use context from middleware stack in children
 5509		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5510	})
 5511	if err != nil {
 5512		ec.Error(ctx, err)
 5513		return graphql.Null
 5514	}
 5515	if resTmp == nil {
 5516		if !graphql.HasFieldError(ctx, fc) {
 5517			ec.Errorf(ctx, "must not be null")
 5518		}
 5519		return graphql.Null
 5520	}
 5521	res := resTmp.(*time.Time)
 5522	fc.Result = res
 5523	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5524}
 5525
 5526func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5527	defer func() {
 5528		if r := recover(); r != nil {
 5529			ec.Error(ctx, ec.Recover(ctx, r))
 5530			ret = graphql.Null
 5531		}
 5532	}()
 5533	fc := &graphql.FieldContext{
 5534		Object:   "CreateTimelineItem",
 5535		Field:    field,
 5536		Args:     nil,
 5537		IsMethod: true,
 5538	}
 5539
 5540	ctx = graphql.WithFieldContext(ctx, fc)
 5541	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5542		ctx = rctx // use context from middleware stack in children
 5543		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5544	})
 5545	if err != nil {
 5546		ec.Error(ctx, err)
 5547		return graphql.Null
 5548	}
 5549	if resTmp == nil {
 5550		if !graphql.HasFieldError(ctx, fc) {
 5551			ec.Errorf(ctx, "must not be null")
 5552		}
 5553		return graphql.Null
 5554	}
 5555	res := resTmp.(*time.Time)
 5556	fc.Result = res
 5557	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5558}
 5559
 5560func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5561	defer func() {
 5562		if r := recover(); r != nil {
 5563			ec.Error(ctx, ec.Recover(ctx, r))
 5564			ret = graphql.Null
 5565		}
 5566	}()
 5567	fc := &graphql.FieldContext{
 5568		Object:   "CreateTimelineItem",
 5569		Field:    field,
 5570		Args:     nil,
 5571		IsMethod: true,
 5572	}
 5573
 5574	ctx = graphql.WithFieldContext(ctx, fc)
 5575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5576		ctx = rctx // use context from middleware stack in children
 5577		return obj.Edited(), nil
 5578	})
 5579	if err != nil {
 5580		ec.Error(ctx, err)
 5581		return graphql.Null
 5582	}
 5583	if resTmp == nil {
 5584		if !graphql.HasFieldError(ctx, fc) {
 5585			ec.Errorf(ctx, "must not be null")
 5586		}
 5587		return graphql.Null
 5588	}
 5589	res := resTmp.(bool)
 5590	fc.Result = res
 5591	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5592}
 5593
 5594func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5595	defer func() {
 5596		if r := recover(); r != nil {
 5597			ec.Error(ctx, ec.Recover(ctx, r))
 5598			ret = graphql.Null
 5599		}
 5600	}()
 5601	fc := &graphql.FieldContext{
 5602		Object:   "CreateTimelineItem",
 5603		Field:    field,
 5604		Args:     nil,
 5605		IsMethod: false,
 5606	}
 5607
 5608	ctx = graphql.WithFieldContext(ctx, fc)
 5609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5610		ctx = rctx // use context from middleware stack in children
 5611		return obj.History, nil
 5612	})
 5613	if err != nil {
 5614		ec.Error(ctx, err)
 5615		return graphql.Null
 5616	}
 5617	if resTmp == nil {
 5618		if !graphql.HasFieldError(ctx, fc) {
 5619			ec.Errorf(ctx, "must not be null")
 5620		}
 5621		return graphql.Null
 5622	}
 5623	res := resTmp.([]bug.CommentHistoryStep)
 5624	fc.Result = res
 5625	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 5626}
 5627
 5628func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5629	defer func() {
 5630		if r := recover(); r != nil {
 5631			ec.Error(ctx, ec.Recover(ctx, r))
 5632			ret = graphql.Null
 5633		}
 5634	}()
 5635	fc := &graphql.FieldContext{
 5636		Object:   "EditCommentOperation",
 5637		Field:    field,
 5638		Args:     nil,
 5639		IsMethod: true,
 5640	}
 5641
 5642	ctx = graphql.WithFieldContext(ctx, fc)
 5643	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5644		ctx = rctx // use context from middleware stack in children
 5645		return ec.resolvers.EditCommentOperation().ID(rctx, obj)
 5646	})
 5647	if err != nil {
 5648		ec.Error(ctx, err)
 5649		return graphql.Null
 5650	}
 5651	if resTmp == nil {
 5652		if !graphql.HasFieldError(ctx, fc) {
 5653			ec.Errorf(ctx, "must not be null")
 5654		}
 5655		return graphql.Null
 5656	}
 5657	res := resTmp.(string)
 5658	fc.Result = res
 5659	return ec.marshalNString2string(ctx, field.Selections, res)
 5660}
 5661
 5662func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5663	defer func() {
 5664		if r := recover(); r != nil {
 5665			ec.Error(ctx, ec.Recover(ctx, r))
 5666			ret = graphql.Null
 5667		}
 5668	}()
 5669	fc := &graphql.FieldContext{
 5670		Object:   "EditCommentOperation",
 5671		Field:    field,
 5672		Args:     nil,
 5673		IsMethod: true,
 5674	}
 5675
 5676	ctx = graphql.WithFieldContext(ctx, fc)
 5677	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5678		ctx = rctx // use context from middleware stack in children
 5679		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
 5680	})
 5681	if err != nil {
 5682		ec.Error(ctx, err)
 5683		return graphql.Null
 5684	}
 5685	if resTmp == nil {
 5686		if !graphql.HasFieldError(ctx, fc) {
 5687			ec.Errorf(ctx, "must not be null")
 5688		}
 5689		return graphql.Null
 5690	}
 5691	res := resTmp.(models.IdentityWrapper)
 5692	fc.Result = res
 5693	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 5694}
 5695
 5696func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5697	defer func() {
 5698		if r := recover(); r != nil {
 5699			ec.Error(ctx, ec.Recover(ctx, r))
 5700			ret = graphql.Null
 5701		}
 5702	}()
 5703	fc := &graphql.FieldContext{
 5704		Object:   "EditCommentOperation",
 5705		Field:    field,
 5706		Args:     nil,
 5707		IsMethod: true,
 5708	}
 5709
 5710	ctx = graphql.WithFieldContext(ctx, fc)
 5711	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5712		ctx = rctx // use context from middleware stack in children
 5713		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5714	})
 5715	if err != nil {
 5716		ec.Error(ctx, err)
 5717		return graphql.Null
 5718	}
 5719	if resTmp == nil {
 5720		if !graphql.HasFieldError(ctx, fc) {
 5721			ec.Errorf(ctx, "must not be null")
 5722		}
 5723		return graphql.Null
 5724	}
 5725	res := resTmp.(*time.Time)
 5726	fc.Result = res
 5727	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5728}
 5729
 5730func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5731	defer func() {
 5732		if r := recover(); r != nil {
 5733			ec.Error(ctx, ec.Recover(ctx, r))
 5734			ret = graphql.Null
 5735		}
 5736	}()
 5737	fc := &graphql.FieldContext{
 5738		Object:   "EditCommentOperation",
 5739		Field:    field,
 5740		Args:     nil,
 5741		IsMethod: true,
 5742	}
 5743
 5744	ctx = graphql.WithFieldContext(ctx, fc)
 5745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5746		ctx = rctx // use context from middleware stack in children
 5747		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
 5748	})
 5749	if err != nil {
 5750		ec.Error(ctx, err)
 5751		return graphql.Null
 5752	}
 5753	if resTmp == nil {
 5754		if !graphql.HasFieldError(ctx, fc) {
 5755			ec.Errorf(ctx, "must not be null")
 5756		}
 5757		return graphql.Null
 5758	}
 5759	res := resTmp.(string)
 5760	fc.Result = res
 5761	return ec.marshalNString2string(ctx, field.Selections, res)
 5762}
 5763
 5764func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5765	defer func() {
 5766		if r := recover(); r != nil {
 5767			ec.Error(ctx, ec.Recover(ctx, r))
 5768			ret = graphql.Null
 5769		}
 5770	}()
 5771	fc := &graphql.FieldContext{
 5772		Object:   "EditCommentOperation",
 5773		Field:    field,
 5774		Args:     nil,
 5775		IsMethod: false,
 5776	}
 5777
 5778	ctx = graphql.WithFieldContext(ctx, fc)
 5779	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5780		ctx = rctx // use context from middleware stack in children
 5781		return obj.Message, nil
 5782	})
 5783	if err != nil {
 5784		ec.Error(ctx, err)
 5785		return graphql.Null
 5786	}
 5787	if resTmp == nil {
 5788		if !graphql.HasFieldError(ctx, fc) {
 5789			ec.Errorf(ctx, "must not be null")
 5790		}
 5791		return graphql.Null
 5792	}
 5793	res := resTmp.(string)
 5794	fc.Result = res
 5795	return ec.marshalNString2string(ctx, field.Selections, res)
 5796}
 5797
 5798func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5799	defer func() {
 5800		if r := recover(); r != nil {
 5801			ec.Error(ctx, ec.Recover(ctx, r))
 5802			ret = graphql.Null
 5803		}
 5804	}()
 5805	fc := &graphql.FieldContext{
 5806		Object:   "EditCommentOperation",
 5807		Field:    field,
 5808		Args:     nil,
 5809		IsMethod: false,
 5810	}
 5811
 5812	ctx = graphql.WithFieldContext(ctx, fc)
 5813	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5814		ctx = rctx // use context from middleware stack in children
 5815		return obj.Files, nil
 5816	})
 5817	if err != nil {
 5818		ec.Error(ctx, err)
 5819		return graphql.Null
 5820	}
 5821	if resTmp == nil {
 5822		if !graphql.HasFieldError(ctx, fc) {
 5823			ec.Errorf(ctx, "must not be null")
 5824		}
 5825		return graphql.Null
 5826	}
 5827	res := resTmp.([]git.Hash)
 5828	fc.Result = res
 5829	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, field.Selections, res)
 5830}
 5831
 5832func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5833	defer func() {
 5834		if r := recover(); r != nil {
 5835			ec.Error(ctx, ec.Recover(ctx, r))
 5836			ret = graphql.Null
 5837		}
 5838	}()
 5839	fc := &graphql.FieldContext{
 5840		Object:   "Identity",
 5841		Field:    field,
 5842		Args:     nil,
 5843		IsMethod: true,
 5844	}
 5845
 5846	ctx = graphql.WithFieldContext(ctx, fc)
 5847	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5848		ctx = rctx // use context from middleware stack in children
 5849		return ec.resolvers.Identity().ID(rctx, obj)
 5850	})
 5851	if err != nil {
 5852		ec.Error(ctx, err)
 5853		return graphql.Null
 5854	}
 5855	if resTmp == nil {
 5856		if !graphql.HasFieldError(ctx, fc) {
 5857			ec.Errorf(ctx, "must not be null")
 5858		}
 5859		return graphql.Null
 5860	}
 5861	res := resTmp.(string)
 5862	fc.Result = res
 5863	return ec.marshalNString2string(ctx, field.Selections, res)
 5864}
 5865
 5866func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5867	defer func() {
 5868		if r := recover(); r != nil {
 5869			ec.Error(ctx, ec.Recover(ctx, r))
 5870			ret = graphql.Null
 5871		}
 5872	}()
 5873	fc := &graphql.FieldContext{
 5874		Object:   "Identity",
 5875		Field:    field,
 5876		Args:     nil,
 5877		IsMethod: true,
 5878	}
 5879
 5880	ctx = graphql.WithFieldContext(ctx, fc)
 5881	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5882		ctx = rctx // use context from middleware stack in children
 5883		return ec.resolvers.Identity().HumanID(rctx, obj)
 5884	})
 5885	if err != nil {
 5886		ec.Error(ctx, err)
 5887		return graphql.Null
 5888	}
 5889	if resTmp == nil {
 5890		if !graphql.HasFieldError(ctx, fc) {
 5891			ec.Errorf(ctx, "must not be null")
 5892		}
 5893		return graphql.Null
 5894	}
 5895	res := resTmp.(string)
 5896	fc.Result = res
 5897	return ec.marshalNString2string(ctx, field.Selections, res)
 5898}
 5899
 5900func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5901	defer func() {
 5902		if r := recover(); r != nil {
 5903			ec.Error(ctx, ec.Recover(ctx, r))
 5904			ret = graphql.Null
 5905		}
 5906	}()
 5907	fc := &graphql.FieldContext{
 5908		Object:   "Identity",
 5909		Field:    field,
 5910		Args:     nil,
 5911		IsMethod: true,
 5912	}
 5913
 5914	ctx = graphql.WithFieldContext(ctx, fc)
 5915	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5916		ctx = rctx // use context from middleware stack in children
 5917		return obj.Name(), nil
 5918	})
 5919	if err != nil {
 5920		ec.Error(ctx, err)
 5921		return graphql.Null
 5922	}
 5923	if resTmp == nil {
 5924		return graphql.Null
 5925	}
 5926	res := resTmp.(string)
 5927	fc.Result = res
 5928	return ec.marshalOString2string(ctx, field.Selections, res)
 5929}
 5930
 5931func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5932	defer func() {
 5933		if r := recover(); r != nil {
 5934			ec.Error(ctx, ec.Recover(ctx, r))
 5935			ret = graphql.Null
 5936		}
 5937	}()
 5938	fc := &graphql.FieldContext{
 5939		Object:   "Identity",
 5940		Field:    field,
 5941		Args:     nil,
 5942		IsMethod: true,
 5943	}
 5944
 5945	ctx = graphql.WithFieldContext(ctx, fc)
 5946	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5947		ctx = rctx // use context from middleware stack in children
 5948		return obj.Email()
 5949	})
 5950	if err != nil {
 5951		ec.Error(ctx, err)
 5952		return graphql.Null
 5953	}
 5954	if resTmp == nil {
 5955		return graphql.Null
 5956	}
 5957	res := resTmp.(string)
 5958	fc.Result = res
 5959	return ec.marshalOString2string(ctx, field.Selections, res)
 5960}
 5961
 5962func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5963	defer func() {
 5964		if r := recover(); r != nil {
 5965			ec.Error(ctx, ec.Recover(ctx, r))
 5966			ret = graphql.Null
 5967		}
 5968	}()
 5969	fc := &graphql.FieldContext{
 5970		Object:   "Identity",
 5971		Field:    field,
 5972		Args:     nil,
 5973		IsMethod: true,
 5974	}
 5975
 5976	ctx = graphql.WithFieldContext(ctx, fc)
 5977	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5978		ctx = rctx // use context from middleware stack in children
 5979		return obj.DisplayName(), nil
 5980	})
 5981	if err != nil {
 5982		ec.Error(ctx, err)
 5983		return graphql.Null
 5984	}
 5985	if resTmp == nil {
 5986		if !graphql.HasFieldError(ctx, fc) {
 5987			ec.Errorf(ctx, "must not be null")
 5988		}
 5989		return graphql.Null
 5990	}
 5991	res := resTmp.(string)
 5992	fc.Result = res
 5993	return ec.marshalNString2string(ctx, field.Selections, res)
 5994}
 5995
 5996func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 5997	defer func() {
 5998		if r := recover(); r != nil {
 5999			ec.Error(ctx, ec.Recover(ctx, r))
 6000			ret = graphql.Null
 6001		}
 6002	}()
 6003	fc := &graphql.FieldContext{
 6004		Object:   "Identity",
 6005		Field:    field,
 6006		Args:     nil,
 6007		IsMethod: true,
 6008	}
 6009
 6010	ctx = graphql.WithFieldContext(ctx, fc)
 6011	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6012		ctx = rctx // use context from middleware stack in children
 6013		return obj.AvatarUrl()
 6014	})
 6015	if err != nil {
 6016		ec.Error(ctx, err)
 6017		return graphql.Null
 6018	}
 6019	if resTmp == nil {
 6020		return graphql.Null
 6021	}
 6022	res := resTmp.(string)
 6023	fc.Result = res
 6024	return ec.marshalOString2string(ctx, field.Selections, res)
 6025}
 6026
 6027func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj models.IdentityWrapper) (ret graphql.Marshaler) {
 6028	defer func() {
 6029		if r := recover(); r != nil {
 6030			ec.Error(ctx, ec.Recover(ctx, r))
 6031			ret = graphql.Null
 6032		}
 6033	}()
 6034	fc := &graphql.FieldContext{
 6035		Object:   "Identity",
 6036		Field:    field,
 6037		Args:     nil,
 6038		IsMethod: true,
 6039	}
 6040
 6041	ctx = graphql.WithFieldContext(ctx, fc)
 6042	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6043		ctx = rctx // use context from middleware stack in children
 6044		return obj.IsProtected()
 6045	})
 6046	if err != nil {
 6047		ec.Error(ctx, err)
 6048		return graphql.Null
 6049	}
 6050	if resTmp == nil {
 6051		if !graphql.HasFieldError(ctx, fc) {
 6052			ec.Errorf(ctx, "must not be null")
 6053		}
 6054		return graphql.Null
 6055	}
 6056	res := resTmp.(bool)
 6057	fc.Result = res
 6058	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6059}
 6060
 6061func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6062	defer func() {
 6063		if r := recover(); r != nil {
 6064			ec.Error(ctx, ec.Recover(ctx, r))
 6065			ret = graphql.Null
 6066		}
 6067	}()
 6068	fc := &graphql.FieldContext{
 6069		Object:   "IdentityConnection",
 6070		Field:    field,
 6071		Args:     nil,
 6072		IsMethod: false,
 6073	}
 6074
 6075	ctx = graphql.WithFieldContext(ctx, fc)
 6076	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6077		ctx = rctx // use context from middleware stack in children
 6078		return obj.Edges, nil
 6079	})
 6080	if err != nil {
 6081		ec.Error(ctx, err)
 6082		return graphql.Null
 6083	}
 6084	if resTmp == nil {
 6085		if !graphql.HasFieldError(ctx, fc) {
 6086			ec.Errorf(ctx, "must not be null")
 6087		}
 6088		return graphql.Null
 6089	}
 6090	res := resTmp.([]*models.IdentityEdge)
 6091	fc.Result = res
 6092	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx, field.Selections, res)
 6093}
 6094
 6095func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6096	defer func() {
 6097		if r := recover(); r != nil {
 6098			ec.Error(ctx, ec.Recover(ctx, r))
 6099			ret = graphql.Null
 6100		}
 6101	}()
 6102	fc := &graphql.FieldContext{
 6103		Object:   "IdentityConnection",
 6104		Field:    field,
 6105		Args:     nil,
 6106		IsMethod: false,
 6107	}
 6108
 6109	ctx = graphql.WithFieldContext(ctx, fc)
 6110	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6111		ctx = rctx // use context from middleware stack in children
 6112		return obj.Nodes, nil
 6113	})
 6114	if err != nil {
 6115		ec.Error(ctx, err)
 6116		return graphql.Null
 6117	}
 6118	if resTmp == nil {
 6119		if !graphql.HasFieldError(ctx, fc) {
 6120			ec.Errorf(ctx, "must not be null")
 6121		}
 6122		return graphql.Null
 6123	}
 6124	res := resTmp.([]models.IdentityWrapper)
 6125	fc.Result = res
 6126	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx, field.Selections, res)
 6127}
 6128
 6129func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6130	defer func() {
 6131		if r := recover(); r != nil {
 6132			ec.Error(ctx, ec.Recover(ctx, r))
 6133			ret = graphql.Null
 6134		}
 6135	}()
 6136	fc := &graphql.FieldContext{
 6137		Object:   "IdentityConnection",
 6138		Field:    field,
 6139		Args:     nil,
 6140		IsMethod: false,
 6141	}
 6142
 6143	ctx = graphql.WithFieldContext(ctx, fc)
 6144	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6145		ctx = rctx // use context from middleware stack in children
 6146		return obj.PageInfo, nil
 6147	})
 6148	if err != nil {
 6149		ec.Error(ctx, err)
 6150		return graphql.Null
 6151	}
 6152	if resTmp == nil {
 6153		if !graphql.HasFieldError(ctx, fc) {
 6154			ec.Errorf(ctx, "must not be null")
 6155		}
 6156		return graphql.Null
 6157	}
 6158	res := resTmp.(*models.PageInfo)
 6159	fc.Result = res
 6160	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6161}
 6162
 6163func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6164	defer func() {
 6165		if r := recover(); r != nil {
 6166			ec.Error(ctx, ec.Recover(ctx, r))
 6167			ret = graphql.Null
 6168		}
 6169	}()
 6170	fc := &graphql.FieldContext{
 6171		Object:   "IdentityConnection",
 6172		Field:    field,
 6173		Args:     nil,
 6174		IsMethod: false,
 6175	}
 6176
 6177	ctx = graphql.WithFieldContext(ctx, fc)
 6178	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6179		ctx = rctx // use context from middleware stack in children
 6180		return obj.TotalCount, nil
 6181	})
 6182	if err != nil {
 6183		ec.Error(ctx, err)
 6184		return graphql.Null
 6185	}
 6186	if resTmp == nil {
 6187		if !graphql.HasFieldError(ctx, fc) {
 6188			ec.Errorf(ctx, "must not be null")
 6189		}
 6190		return graphql.Null
 6191	}
 6192	res := resTmp.(int)
 6193	fc.Result = res
 6194	return ec.marshalNInt2int(ctx, field.Selections, res)
 6195}
 6196
 6197func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6198	defer func() {
 6199		if r := recover(); r != nil {
 6200			ec.Error(ctx, ec.Recover(ctx, r))
 6201			ret = graphql.Null
 6202		}
 6203	}()
 6204	fc := &graphql.FieldContext{
 6205		Object:   "IdentityEdge",
 6206		Field:    field,
 6207		Args:     nil,
 6208		IsMethod: false,
 6209	}
 6210
 6211	ctx = graphql.WithFieldContext(ctx, fc)
 6212	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6213		ctx = rctx // use context from middleware stack in children
 6214		return obj.Cursor, nil
 6215	})
 6216	if err != nil {
 6217		ec.Error(ctx, err)
 6218		return graphql.Null
 6219	}
 6220	if resTmp == nil {
 6221		if !graphql.HasFieldError(ctx, fc) {
 6222			ec.Errorf(ctx, "must not be null")
 6223		}
 6224		return graphql.Null
 6225	}
 6226	res := resTmp.(string)
 6227	fc.Result = res
 6228	return ec.marshalNString2string(ctx, field.Selections, res)
 6229}
 6230
 6231func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6232	defer func() {
 6233		if r := recover(); r != nil {
 6234			ec.Error(ctx, ec.Recover(ctx, r))
 6235			ret = graphql.Null
 6236		}
 6237	}()
 6238	fc := &graphql.FieldContext{
 6239		Object:   "IdentityEdge",
 6240		Field:    field,
 6241		Args:     nil,
 6242		IsMethod: false,
 6243	}
 6244
 6245	ctx = graphql.WithFieldContext(ctx, fc)
 6246	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6247		ctx = rctx // use context from middleware stack in children
 6248		return obj.Node, nil
 6249	})
 6250	if err != nil {
 6251		ec.Error(ctx, err)
 6252		return graphql.Null
 6253	}
 6254	if resTmp == nil {
 6255		if !graphql.HasFieldError(ctx, fc) {
 6256			ec.Errorf(ctx, "must not be null")
 6257		}
 6258		return graphql.Null
 6259	}
 6260	res := resTmp.(models.IdentityWrapper)
 6261	fc.Result = res
 6262	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6263}
 6264
 6265func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6266	defer func() {
 6267		if r := recover(); r != nil {
 6268			ec.Error(ctx, ec.Recover(ctx, r))
 6269			ret = graphql.Null
 6270		}
 6271	}()
 6272	fc := &graphql.FieldContext{
 6273		Object:   "Label",
 6274		Field:    field,
 6275		Args:     nil,
 6276		IsMethod: true,
 6277	}
 6278
 6279	ctx = graphql.WithFieldContext(ctx, fc)
 6280	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6281		ctx = rctx // use context from middleware stack in children
 6282		return ec.resolvers.Label().Name(rctx, obj)
 6283	})
 6284	if err != nil {
 6285		ec.Error(ctx, err)
 6286		return graphql.Null
 6287	}
 6288	if resTmp == nil {
 6289		if !graphql.HasFieldError(ctx, fc) {
 6290			ec.Errorf(ctx, "must not be null")
 6291		}
 6292		return graphql.Null
 6293	}
 6294	res := resTmp.(string)
 6295	fc.Result = res
 6296	return ec.marshalNString2string(ctx, field.Selections, res)
 6297}
 6298
 6299func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6300	defer func() {
 6301		if r := recover(); r != nil {
 6302			ec.Error(ctx, ec.Recover(ctx, r))
 6303			ret = graphql.Null
 6304		}
 6305	}()
 6306	fc := &graphql.FieldContext{
 6307		Object:   "Label",
 6308		Field:    field,
 6309		Args:     nil,
 6310		IsMethod: true,
 6311	}
 6312
 6313	ctx = graphql.WithFieldContext(ctx, fc)
 6314	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6315		ctx = rctx // use context from middleware stack in children
 6316		return ec.resolvers.Label().Color(rctx, obj)
 6317	})
 6318	if err != nil {
 6319		ec.Error(ctx, err)
 6320		return graphql.Null
 6321	}
 6322	if resTmp == nil {
 6323		if !graphql.HasFieldError(ctx, fc) {
 6324			ec.Errorf(ctx, "must not be null")
 6325		}
 6326		return graphql.Null
 6327	}
 6328	res := resTmp.(*color.RGBA)
 6329	fc.Result = res
 6330	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6331}
 6332
 6333func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6334	defer func() {
 6335		if r := recover(); r != nil {
 6336			ec.Error(ctx, ec.Recover(ctx, r))
 6337			ret = graphql.Null
 6338		}
 6339	}()
 6340	fc := &graphql.FieldContext{
 6341		Object:   "LabelChangeOperation",
 6342		Field:    field,
 6343		Args:     nil,
 6344		IsMethod: true,
 6345	}
 6346
 6347	ctx = graphql.WithFieldContext(ctx, fc)
 6348	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6349		ctx = rctx // use context from middleware stack in children
 6350		return ec.resolvers.LabelChangeOperation().ID(rctx, obj)
 6351	})
 6352	if err != nil {
 6353		ec.Error(ctx, err)
 6354		return graphql.Null
 6355	}
 6356	if resTmp == nil {
 6357		if !graphql.HasFieldError(ctx, fc) {
 6358			ec.Errorf(ctx, "must not be null")
 6359		}
 6360		return graphql.Null
 6361	}
 6362	res := resTmp.(string)
 6363	fc.Result = res
 6364	return ec.marshalNString2string(ctx, field.Selections, res)
 6365}
 6366
 6367func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6368	defer func() {
 6369		if r := recover(); r != nil {
 6370			ec.Error(ctx, ec.Recover(ctx, r))
 6371			ret = graphql.Null
 6372		}
 6373	}()
 6374	fc := &graphql.FieldContext{
 6375		Object:   "LabelChangeOperation",
 6376		Field:    field,
 6377		Args:     nil,
 6378		IsMethod: true,
 6379	}
 6380
 6381	ctx = graphql.WithFieldContext(ctx, fc)
 6382	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6383		ctx = rctx // use context from middleware stack in children
 6384		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
 6385	})
 6386	if err != nil {
 6387		ec.Error(ctx, err)
 6388		return graphql.Null
 6389	}
 6390	if resTmp == nil {
 6391		if !graphql.HasFieldError(ctx, fc) {
 6392			ec.Errorf(ctx, "must not be null")
 6393		}
 6394		return graphql.Null
 6395	}
 6396	res := resTmp.(models.IdentityWrapper)
 6397	fc.Result = res
 6398	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6399}
 6400
 6401func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6402	defer func() {
 6403		if r := recover(); r != nil {
 6404			ec.Error(ctx, ec.Recover(ctx, r))
 6405			ret = graphql.Null
 6406		}
 6407	}()
 6408	fc := &graphql.FieldContext{
 6409		Object:   "LabelChangeOperation",
 6410		Field:    field,
 6411		Args:     nil,
 6412		IsMethod: true,
 6413	}
 6414
 6415	ctx = graphql.WithFieldContext(ctx, fc)
 6416	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6417		ctx = rctx // use context from middleware stack in children
 6418		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6419	})
 6420	if err != nil {
 6421		ec.Error(ctx, err)
 6422		return graphql.Null
 6423	}
 6424	if resTmp == nil {
 6425		if !graphql.HasFieldError(ctx, fc) {
 6426			ec.Errorf(ctx, "must not be null")
 6427		}
 6428		return graphql.Null
 6429	}
 6430	res := resTmp.(*time.Time)
 6431	fc.Result = res
 6432	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6433}
 6434
 6435func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6436	defer func() {
 6437		if r := recover(); r != nil {
 6438			ec.Error(ctx, ec.Recover(ctx, r))
 6439			ret = graphql.Null
 6440		}
 6441	}()
 6442	fc := &graphql.FieldContext{
 6443		Object:   "LabelChangeOperation",
 6444		Field:    field,
 6445		Args:     nil,
 6446		IsMethod: false,
 6447	}
 6448
 6449	ctx = graphql.WithFieldContext(ctx, fc)
 6450	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6451		ctx = rctx // use context from middleware stack in children
 6452		return obj.Added, nil
 6453	})
 6454	if err != nil {
 6455		ec.Error(ctx, err)
 6456		return graphql.Null
 6457	}
 6458	if resTmp == nil {
 6459		if !graphql.HasFieldError(ctx, fc) {
 6460			ec.Errorf(ctx, "must not be null")
 6461		}
 6462		return graphql.Null
 6463	}
 6464	res := resTmp.([]bug.Label)
 6465	fc.Result = res
 6466	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6467}
 6468
 6469func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6470	defer func() {
 6471		if r := recover(); r != nil {
 6472			ec.Error(ctx, ec.Recover(ctx, r))
 6473			ret = graphql.Null
 6474		}
 6475	}()
 6476	fc := &graphql.FieldContext{
 6477		Object:   "LabelChangeOperation",
 6478		Field:    field,
 6479		Args:     nil,
 6480		IsMethod: false,
 6481	}
 6482
 6483	ctx = graphql.WithFieldContext(ctx, fc)
 6484	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6485		ctx = rctx // use context from middleware stack in children
 6486		return obj.Removed, nil
 6487	})
 6488	if err != nil {
 6489		ec.Error(ctx, err)
 6490		return graphql.Null
 6491	}
 6492	if resTmp == nil {
 6493		if !graphql.HasFieldError(ctx, fc) {
 6494			ec.Errorf(ctx, "must not be null")
 6495		}
 6496		return graphql.Null
 6497	}
 6498	res := resTmp.([]bug.Label)
 6499	fc.Result = res
 6500	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6501}
 6502
 6503func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6504	defer func() {
 6505		if r := recover(); r != nil {
 6506			ec.Error(ctx, ec.Recover(ctx, r))
 6507			ret = graphql.Null
 6508		}
 6509	}()
 6510	fc := &graphql.FieldContext{
 6511		Object:   "LabelChangeResult",
 6512		Field:    field,
 6513		Args:     nil,
 6514		IsMethod: false,
 6515	}
 6516
 6517	ctx = graphql.WithFieldContext(ctx, fc)
 6518	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6519		ctx = rctx // use context from middleware stack in children
 6520		return obj.Label, nil
 6521	})
 6522	if err != nil {
 6523		ec.Error(ctx, err)
 6524		return graphql.Null
 6525	}
 6526	if resTmp == nil {
 6527		if !graphql.HasFieldError(ctx, fc) {
 6528			ec.Errorf(ctx, "must not be null")
 6529		}
 6530		return graphql.Null
 6531	}
 6532	res := resTmp.(bug.Label)
 6533	fc.Result = res
 6534	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6535}
 6536
 6537func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6538	defer func() {
 6539		if r := recover(); r != nil {
 6540			ec.Error(ctx, ec.Recover(ctx, r))
 6541			ret = graphql.Null
 6542		}
 6543	}()
 6544	fc := &graphql.FieldContext{
 6545		Object:   "LabelChangeResult",
 6546		Field:    field,
 6547		Args:     nil,
 6548		IsMethod: true,
 6549	}
 6550
 6551	ctx = graphql.WithFieldContext(ctx, fc)
 6552	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6553		ctx = rctx // use context from middleware stack in children
 6554		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6555	})
 6556	if err != nil {
 6557		ec.Error(ctx, err)
 6558		return graphql.Null
 6559	}
 6560	if resTmp == nil {
 6561		if !graphql.HasFieldError(ctx, fc) {
 6562			ec.Errorf(ctx, "must not be null")
 6563		}
 6564		return graphql.Null
 6565	}
 6566	res := resTmp.(models.LabelChangeStatus)
 6567	fc.Result = res
 6568	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6569}
 6570
 6571func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6572	defer func() {
 6573		if r := recover(); r != nil {
 6574			ec.Error(ctx, ec.Recover(ctx, r))
 6575			ret = graphql.Null
 6576		}
 6577	}()
 6578	fc := &graphql.FieldContext{
 6579		Object:   "LabelChangeTimelineItem",
 6580		Field:    field,
 6581		Args:     nil,
 6582		IsMethod: true,
 6583	}
 6584
 6585	ctx = graphql.WithFieldContext(ctx, fc)
 6586	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6587		ctx = rctx // use context from middleware stack in children
 6588		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
 6589	})
 6590	if err != nil {
 6591		ec.Error(ctx, err)
 6592		return graphql.Null
 6593	}
 6594	if resTmp == nil {
 6595		if !graphql.HasFieldError(ctx, fc) {
 6596			ec.Errorf(ctx, "must not be null")
 6597		}
 6598		return graphql.Null
 6599	}
 6600	res := resTmp.(string)
 6601	fc.Result = res
 6602	return ec.marshalNString2string(ctx, field.Selections, res)
 6603}
 6604
 6605func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6606	defer func() {
 6607		if r := recover(); r != nil {
 6608			ec.Error(ctx, ec.Recover(ctx, r))
 6609			ret = graphql.Null
 6610		}
 6611	}()
 6612	fc := &graphql.FieldContext{
 6613		Object:   "LabelChangeTimelineItem",
 6614		Field:    field,
 6615		Args:     nil,
 6616		IsMethod: true,
 6617	}
 6618
 6619	ctx = graphql.WithFieldContext(ctx, fc)
 6620	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6621		ctx = rctx // use context from middleware stack in children
 6622		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
 6623	})
 6624	if err != nil {
 6625		ec.Error(ctx, err)
 6626		return graphql.Null
 6627	}
 6628	if resTmp == nil {
 6629		if !graphql.HasFieldError(ctx, fc) {
 6630			ec.Errorf(ctx, "must not be null")
 6631		}
 6632		return graphql.Null
 6633	}
 6634	res := resTmp.(models.IdentityWrapper)
 6635	fc.Result = res
 6636	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 6637}
 6638
 6639func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6640	defer func() {
 6641		if r := recover(); r != nil {
 6642			ec.Error(ctx, ec.Recover(ctx, r))
 6643			ret = graphql.Null
 6644		}
 6645	}()
 6646	fc := &graphql.FieldContext{
 6647		Object:   "LabelChangeTimelineItem",
 6648		Field:    field,
 6649		Args:     nil,
 6650		IsMethod: true,
 6651	}
 6652
 6653	ctx = graphql.WithFieldContext(ctx, fc)
 6654	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6655		ctx = rctx // use context from middleware stack in children
 6656		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6657	})
 6658	if err != nil {
 6659		ec.Error(ctx, err)
 6660		return graphql.Null
 6661	}
 6662	if resTmp == nil {
 6663		if !graphql.HasFieldError(ctx, fc) {
 6664			ec.Errorf(ctx, "must not be null")
 6665		}
 6666		return graphql.Null
 6667	}
 6668	res := resTmp.(*time.Time)
 6669	fc.Result = res
 6670	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6671}
 6672
 6673func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6674	defer func() {
 6675		if r := recover(); r != nil {
 6676			ec.Error(ctx, ec.Recover(ctx, r))
 6677			ret = graphql.Null
 6678		}
 6679	}()
 6680	fc := &graphql.FieldContext{
 6681		Object:   "LabelChangeTimelineItem",
 6682		Field:    field,
 6683		Args:     nil,
 6684		IsMethod: false,
 6685	}
 6686
 6687	ctx = graphql.WithFieldContext(ctx, fc)
 6688	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6689		ctx = rctx // use context from middleware stack in children
 6690		return obj.Added, nil
 6691	})
 6692	if err != nil {
 6693		ec.Error(ctx, err)
 6694		return graphql.Null
 6695	}
 6696	if resTmp == nil {
 6697		if !graphql.HasFieldError(ctx, fc) {
 6698			ec.Errorf(ctx, "must not be null")
 6699		}
 6700		return graphql.Null
 6701	}
 6702	res := resTmp.([]bug.Label)
 6703	fc.Result = res
 6704	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6705}
 6706
 6707func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6708	defer func() {
 6709		if r := recover(); r != nil {
 6710			ec.Error(ctx, ec.Recover(ctx, r))
 6711			ret = graphql.Null
 6712		}
 6713	}()
 6714	fc := &graphql.FieldContext{
 6715		Object:   "LabelChangeTimelineItem",
 6716		Field:    field,
 6717		Args:     nil,
 6718		IsMethod: false,
 6719	}
 6720
 6721	ctx = graphql.WithFieldContext(ctx, fc)
 6722	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6723		ctx = rctx // use context from middleware stack in children
 6724		return obj.Removed, nil
 6725	})
 6726	if err != nil {
 6727		ec.Error(ctx, err)
 6728		return graphql.Null
 6729	}
 6730	if resTmp == nil {
 6731		if !graphql.HasFieldError(ctx, fc) {
 6732			ec.Errorf(ctx, "must not be null")
 6733		}
 6734		return graphql.Null
 6735	}
 6736	res := resTmp.([]bug.Label)
 6737	fc.Result = res
 6738	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6739}
 6740
 6741func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6742	defer func() {
 6743		if r := recover(); r != nil {
 6744			ec.Error(ctx, ec.Recover(ctx, r))
 6745			ret = graphql.Null
 6746		}
 6747	}()
 6748	fc := &graphql.FieldContext{
 6749		Object:   "LabelConnection",
 6750		Field:    field,
 6751		Args:     nil,
 6752		IsMethod: false,
 6753	}
 6754
 6755	ctx = graphql.WithFieldContext(ctx, fc)
 6756	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6757		ctx = rctx // use context from middleware stack in children
 6758		return obj.Edges, nil
 6759	})
 6760	if err != nil {
 6761		ec.Error(ctx, err)
 6762		return graphql.Null
 6763	}
 6764	if resTmp == nil {
 6765		if !graphql.HasFieldError(ctx, fc) {
 6766			ec.Errorf(ctx, "must not be null")
 6767		}
 6768		return graphql.Null
 6769	}
 6770	res := resTmp.([]*models.LabelEdge)
 6771	fc.Result = res
 6772	return ec.marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx, field.Selections, res)
 6773}
 6774
 6775func (ec *executionContext) _LabelConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6776	defer func() {
 6777		if r := recover(); r != nil {
 6778			ec.Error(ctx, ec.Recover(ctx, r))
 6779			ret = graphql.Null
 6780		}
 6781	}()
 6782	fc := &graphql.FieldContext{
 6783		Object:   "LabelConnection",
 6784		Field:    field,
 6785		Args:     nil,
 6786		IsMethod: false,
 6787	}
 6788
 6789	ctx = graphql.WithFieldContext(ctx, fc)
 6790	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6791		ctx = rctx // use context from middleware stack in children
 6792		return obj.Nodes, nil
 6793	})
 6794	if err != nil {
 6795		ec.Error(ctx, err)
 6796		return graphql.Null
 6797	}
 6798	if resTmp == nil {
 6799		if !graphql.HasFieldError(ctx, fc) {
 6800			ec.Errorf(ctx, "must not be null")
 6801		}
 6802		return graphql.Null
 6803	}
 6804	res := resTmp.([]bug.Label)
 6805	fc.Result = res
 6806	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx, field.Selections, res)
 6807}
 6808
 6809func (ec *executionContext) _LabelConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6810	defer func() {
 6811		if r := recover(); r != nil {
 6812			ec.Error(ctx, ec.Recover(ctx, r))
 6813			ret = graphql.Null
 6814		}
 6815	}()
 6816	fc := &graphql.FieldContext{
 6817		Object:   "LabelConnection",
 6818		Field:    field,
 6819		Args:     nil,
 6820		IsMethod: false,
 6821	}
 6822
 6823	ctx = graphql.WithFieldContext(ctx, fc)
 6824	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6825		ctx = rctx // use context from middleware stack in children
 6826		return obj.PageInfo, nil
 6827	})
 6828	if err != nil {
 6829		ec.Error(ctx, err)
 6830		return graphql.Null
 6831	}
 6832	if resTmp == nil {
 6833		if !graphql.HasFieldError(ctx, fc) {
 6834			ec.Errorf(ctx, "must not be null")
 6835		}
 6836		return graphql.Null
 6837	}
 6838	res := resTmp.(*models.PageInfo)
 6839	fc.Result = res
 6840	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6841}
 6842
 6843func (ec *executionContext) _LabelConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 6844	defer func() {
 6845		if r := recover(); r != nil {
 6846			ec.Error(ctx, ec.Recover(ctx, r))
 6847			ret = graphql.Null
 6848		}
 6849	}()
 6850	fc := &graphql.FieldContext{
 6851		Object:   "LabelConnection",
 6852		Field:    field,
 6853		Args:     nil,
 6854		IsMethod: false,
 6855	}
 6856
 6857	ctx = graphql.WithFieldContext(ctx, fc)
 6858	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6859		ctx = rctx // use context from middleware stack in children
 6860		return obj.TotalCount, nil
 6861	})
 6862	if err != nil {
 6863		ec.Error(ctx, err)
 6864		return graphql.Null
 6865	}
 6866	if resTmp == nil {
 6867		if !graphql.HasFieldError(ctx, fc) {
 6868			ec.Errorf(ctx, "must not be null")
 6869		}
 6870		return graphql.Null
 6871	}
 6872	res := resTmp.(int)
 6873	fc.Result = res
 6874	return ec.marshalNInt2int(ctx, field.Selections, res)
 6875}
 6876
 6877func (ec *executionContext) _LabelEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6878	defer func() {
 6879		if r := recover(); r != nil {
 6880			ec.Error(ctx, ec.Recover(ctx, r))
 6881			ret = graphql.Null
 6882		}
 6883	}()
 6884	fc := &graphql.FieldContext{
 6885		Object:   "LabelEdge",
 6886		Field:    field,
 6887		Args:     nil,
 6888		IsMethod: false,
 6889	}
 6890
 6891	ctx = graphql.WithFieldContext(ctx, fc)
 6892	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6893		ctx = rctx // use context from middleware stack in children
 6894		return obj.Cursor, nil
 6895	})
 6896	if err != nil {
 6897		ec.Error(ctx, err)
 6898		return graphql.Null
 6899	}
 6900	if resTmp == nil {
 6901		if !graphql.HasFieldError(ctx, fc) {
 6902			ec.Errorf(ctx, "must not be null")
 6903		}
 6904		return graphql.Null
 6905	}
 6906	res := resTmp.(string)
 6907	fc.Result = res
 6908	return ec.marshalNString2string(ctx, field.Selections, res)
 6909}
 6910
 6911func (ec *executionContext) _LabelEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.LabelEdge) (ret graphql.Marshaler) {
 6912	defer func() {
 6913		if r := recover(); r != nil {
 6914			ec.Error(ctx, ec.Recover(ctx, r))
 6915			ret = graphql.Null
 6916		}
 6917	}()
 6918	fc := &graphql.FieldContext{
 6919		Object:   "LabelEdge",
 6920		Field:    field,
 6921		Args:     nil,
 6922		IsMethod: false,
 6923	}
 6924
 6925	ctx = graphql.WithFieldContext(ctx, fc)
 6926	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6927		ctx = rctx // use context from middleware stack in children
 6928		return obj.Node, nil
 6929	})
 6930	if err != nil {
 6931		ec.Error(ctx, err)
 6932		return graphql.Null
 6933	}
 6934	if resTmp == nil {
 6935		if !graphql.HasFieldError(ctx, fc) {
 6936			ec.Errorf(ctx, "must not be null")
 6937		}
 6938		return graphql.Null
 6939	}
 6940	res := resTmp.(bug.Label)
 6941	fc.Result = res
 6942	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6943}
 6944
 6945func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6946	defer func() {
 6947		if r := recover(); r != nil {
 6948			ec.Error(ctx, ec.Recover(ctx, r))
 6949			ret = graphql.Null
 6950		}
 6951	}()
 6952	fc := &graphql.FieldContext{
 6953		Object:   "Mutation",
 6954		Field:    field,
 6955		Args:     nil,
 6956		IsMethod: true,
 6957	}
 6958
 6959	ctx = graphql.WithFieldContext(ctx, fc)
 6960	rawArgs := field.ArgumentMap(ec.Variables)
 6961	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6962	if err != nil {
 6963		ec.Error(ctx, err)
 6964		return graphql.Null
 6965	}
 6966	fc.Args = args
 6967	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6968		ctx = rctx // use context from middleware stack in children
 6969		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 6970	})
 6971	if err != nil {
 6972		ec.Error(ctx, err)
 6973		return graphql.Null
 6974	}
 6975	if resTmp == nil {
 6976		if !graphql.HasFieldError(ctx, fc) {
 6977			ec.Errorf(ctx, "must not be null")
 6978		}
 6979		return graphql.Null
 6980	}
 6981	res := resTmp.(*models.NewBugPayload)
 6982	fc.Result = res
 6983	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 6984}
 6985
 6986func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6987	defer func() {
 6988		if r := recover(); r != nil {
 6989			ec.Error(ctx, ec.Recover(ctx, r))
 6990			ret = graphql.Null
 6991		}
 6992	}()
 6993	fc := &graphql.FieldContext{
 6994		Object:   "Mutation",
 6995		Field:    field,
 6996		Args:     nil,
 6997		IsMethod: true,
 6998	}
 6999
 7000	ctx = graphql.WithFieldContext(ctx, fc)
 7001	rawArgs := field.ArgumentMap(ec.Variables)
 7002	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 7003	if err != nil {
 7004		ec.Error(ctx, err)
 7005		return graphql.Null
 7006	}
 7007	fc.Args = args
 7008	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7009		ctx = rctx // use context from middleware stack in children
 7010		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 7011	})
 7012	if err != nil {
 7013		ec.Error(ctx, err)
 7014		return graphql.Null
 7015	}
 7016	if resTmp == nil {
 7017		if !graphql.HasFieldError(ctx, fc) {
 7018			ec.Errorf(ctx, "must not be null")
 7019		}
 7020		return graphql.Null
 7021	}
 7022	res := resTmp.(*models.AddCommentPayload)
 7023	fc.Result = res
 7024	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 7025}
 7026
 7027func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7028	defer func() {
 7029		if r := recover(); r != nil {
 7030			ec.Error(ctx, ec.Recover(ctx, r))
 7031			ret = graphql.Null
 7032		}
 7033	}()
 7034	fc := &graphql.FieldContext{
 7035		Object:   "Mutation",
 7036		Field:    field,
 7037		Args:     nil,
 7038		IsMethod: true,
 7039	}
 7040
 7041	ctx = graphql.WithFieldContext(ctx, fc)
 7042	rawArgs := field.ArgumentMap(ec.Variables)
 7043	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 7044	if err != nil {
 7045		ec.Error(ctx, err)
 7046		return graphql.Null
 7047	}
 7048	fc.Args = args
 7049	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7050		ctx = rctx // use context from middleware stack in children
 7051		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 7052	})
 7053	if err != nil {
 7054		ec.Error(ctx, err)
 7055		return graphql.Null
 7056	}
 7057	if resTmp == nil {
 7058		if !graphql.HasFieldError(ctx, fc) {
 7059			ec.Errorf(ctx, "must not be null")
 7060		}
 7061		return graphql.Null
 7062	}
 7063	res := resTmp.(*models.ChangeLabelPayload)
 7064	fc.Result = res
 7065	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 7066}
 7067
 7068func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7069	defer func() {
 7070		if r := recover(); r != nil {
 7071			ec.Error(ctx, ec.Recover(ctx, r))
 7072			ret = graphql.Null
 7073		}
 7074	}()
 7075	fc := &graphql.FieldContext{
 7076		Object:   "Mutation",
 7077		Field:    field,
 7078		Args:     nil,
 7079		IsMethod: true,
 7080	}
 7081
 7082	ctx = graphql.WithFieldContext(ctx, fc)
 7083	rawArgs := field.ArgumentMap(ec.Variables)
 7084	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 7085	if err != nil {
 7086		ec.Error(ctx, err)
 7087		return graphql.Null
 7088	}
 7089	fc.Args = args
 7090	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7091		ctx = rctx // use context from middleware stack in children
 7092		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 7093	})
 7094	if err != nil {
 7095		ec.Error(ctx, err)
 7096		return graphql.Null
 7097	}
 7098	if resTmp == nil {
 7099		if !graphql.HasFieldError(ctx, fc) {
 7100			ec.Errorf(ctx, "must not be null")
 7101		}
 7102		return graphql.Null
 7103	}
 7104	res := resTmp.(*models.OpenBugPayload)
 7105	fc.Result = res
 7106	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 7107}
 7108
 7109func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7110	defer func() {
 7111		if r := recover(); r != nil {
 7112			ec.Error(ctx, ec.Recover(ctx, r))
 7113			ret = graphql.Null
 7114		}
 7115	}()
 7116	fc := &graphql.FieldContext{
 7117		Object:   "Mutation",
 7118		Field:    field,
 7119		Args:     nil,
 7120		IsMethod: true,
 7121	}
 7122
 7123	ctx = graphql.WithFieldContext(ctx, fc)
 7124	rawArgs := field.ArgumentMap(ec.Variables)
 7125	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 7126	if err != nil {
 7127		ec.Error(ctx, err)
 7128		return graphql.Null
 7129	}
 7130	fc.Args = args
 7131	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7132		ctx = rctx // use context from middleware stack in children
 7133		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 7134	})
 7135	if err != nil {
 7136		ec.Error(ctx, err)
 7137		return graphql.Null
 7138	}
 7139	if resTmp == nil {
 7140		if !graphql.HasFieldError(ctx, fc) {
 7141			ec.Errorf(ctx, "must not be null")
 7142		}
 7143		return graphql.Null
 7144	}
 7145	res := resTmp.(*models.CloseBugPayload)
 7146	fc.Result = res
 7147	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 7148}
 7149
 7150func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7151	defer func() {
 7152		if r := recover(); r != nil {
 7153			ec.Error(ctx, ec.Recover(ctx, r))
 7154			ret = graphql.Null
 7155		}
 7156	}()
 7157	fc := &graphql.FieldContext{
 7158		Object:   "Mutation",
 7159		Field:    field,
 7160		Args:     nil,
 7161		IsMethod: true,
 7162	}
 7163
 7164	ctx = graphql.WithFieldContext(ctx, fc)
 7165	rawArgs := field.ArgumentMap(ec.Variables)
 7166	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 7167	if err != nil {
 7168		ec.Error(ctx, err)
 7169		return graphql.Null
 7170	}
 7171	fc.Args = args
 7172	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7173		ctx = rctx // use context from middleware stack in children
 7174		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 7175	})
 7176	if err != nil {
 7177		ec.Error(ctx, err)
 7178		return graphql.Null
 7179	}
 7180	if resTmp == nil {
 7181		if !graphql.HasFieldError(ctx, fc) {
 7182			ec.Errorf(ctx, "must not be null")
 7183		}
 7184		return graphql.Null
 7185	}
 7186	res := resTmp.(*models.SetTitlePayload)
 7187	fc.Result = res
 7188	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 7189}
 7190
 7191func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7192	defer func() {
 7193		if r := recover(); r != nil {
 7194			ec.Error(ctx, ec.Recover(ctx, r))
 7195			ret = graphql.Null
 7196		}
 7197	}()
 7198	fc := &graphql.FieldContext{
 7199		Object:   "Mutation",
 7200		Field:    field,
 7201		Args:     nil,
 7202		IsMethod: true,
 7203	}
 7204
 7205	ctx = graphql.WithFieldContext(ctx, fc)
 7206	rawArgs := field.ArgumentMap(ec.Variables)
 7207	args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
 7208	if err != nil {
 7209		ec.Error(ctx, err)
 7210		return graphql.Null
 7211	}
 7212	fc.Args = args
 7213	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7214		ctx = rctx // use context from middleware stack in children
 7215		return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
 7216	})
 7217	if err != nil {
 7218		ec.Error(ctx, err)
 7219		return graphql.Null
 7220	}
 7221	if resTmp == nil {
 7222		if !graphql.HasFieldError(ctx, fc) {
 7223			ec.Errorf(ctx, "must not be null")
 7224		}
 7225		return graphql.Null
 7226	}
 7227	res := resTmp.(*models.CommitPayload)
 7228	fc.Result = res
 7229	return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
 7230}
 7231
 7232func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7233	defer func() {
 7234		if r := recover(); r != nil {
 7235			ec.Error(ctx, ec.Recover(ctx, r))
 7236			ret = graphql.Null
 7237		}
 7238	}()
 7239	fc := &graphql.FieldContext{
 7240		Object:   "Mutation",
 7241		Field:    field,
 7242		Args:     nil,
 7243		IsMethod: true,
 7244	}
 7245
 7246	ctx = graphql.WithFieldContext(ctx, fc)
 7247	rawArgs := field.ArgumentMap(ec.Variables)
 7248	args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
 7249	if err != nil {
 7250		ec.Error(ctx, err)
 7251		return graphql.Null
 7252	}
 7253	fc.Args = args
 7254	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7255		ctx = rctx // use context from middleware stack in children
 7256		return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
 7257	})
 7258	if err != nil {
 7259		ec.Error(ctx, err)
 7260		return graphql.Null
 7261	}
 7262	if resTmp == nil {
 7263		if !graphql.HasFieldError(ctx, fc) {
 7264			ec.Errorf(ctx, "must not be null")
 7265		}
 7266		return graphql.Null
 7267	}
 7268	res := resTmp.(*models.CommitAsNeededPayload)
 7269	fc.Result = res
 7270	return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
 7271}
 7272
 7273func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7274	defer func() {
 7275		if r := recover(); r != nil {
 7276			ec.Error(ctx, ec.Recover(ctx, r))
 7277			ret = graphql.Null
 7278		}
 7279	}()
 7280	fc := &graphql.FieldContext{
 7281		Object:   "NewBugPayload",
 7282		Field:    field,
 7283		Args:     nil,
 7284		IsMethod: false,
 7285	}
 7286
 7287	ctx = graphql.WithFieldContext(ctx, fc)
 7288	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7289		ctx = rctx // use context from middleware stack in children
 7290		return obj.ClientMutationID, nil
 7291	})
 7292	if err != nil {
 7293		ec.Error(ctx, err)
 7294		return graphql.Null
 7295	}
 7296	if resTmp == nil {
 7297		return graphql.Null
 7298	}
 7299	res := resTmp.(*string)
 7300	fc.Result = res
 7301	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7302}
 7303
 7304func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (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:   "NewBugPayload",
 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.Bug, nil
 7322	})
 7323	if err != nil {
 7324		ec.Error(ctx, err)
 7325		return graphql.Null
 7326	}
 7327	if resTmp == nil {
 7328		if !graphql.HasFieldError(ctx, fc) {
 7329			ec.Errorf(ctx, "must not be null")
 7330		}
 7331		return graphql.Null
 7332	}
 7333	res := resTmp.(models.BugWrapper)
 7334	fc.Result = res
 7335	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7336}
 7337
 7338func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7339	defer func() {
 7340		if r := recover(); r != nil {
 7341			ec.Error(ctx, ec.Recover(ctx, r))
 7342			ret = graphql.Null
 7343		}
 7344	}()
 7345	fc := &graphql.FieldContext{
 7346		Object:   "NewBugPayload",
 7347		Field:    field,
 7348		Args:     nil,
 7349		IsMethod: false,
 7350	}
 7351
 7352	ctx = graphql.WithFieldContext(ctx, fc)
 7353	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7354		ctx = rctx // use context from middleware stack in children
 7355		return obj.Operation, nil
 7356	})
 7357	if err != nil {
 7358		ec.Error(ctx, err)
 7359		return graphql.Null
 7360	}
 7361	if resTmp == nil {
 7362		if !graphql.HasFieldError(ctx, fc) {
 7363			ec.Errorf(ctx, "must not be null")
 7364		}
 7365		return graphql.Null
 7366	}
 7367	res := resTmp.(*bug.CreateOperation)
 7368	fc.Result = res
 7369	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7370}
 7371
 7372func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7373	defer func() {
 7374		if r := recover(); r != nil {
 7375			ec.Error(ctx, ec.Recover(ctx, r))
 7376			ret = graphql.Null
 7377		}
 7378	}()
 7379	fc := &graphql.FieldContext{
 7380		Object:   "OpenBugPayload",
 7381		Field:    field,
 7382		Args:     nil,
 7383		IsMethod: false,
 7384	}
 7385
 7386	ctx = graphql.WithFieldContext(ctx, fc)
 7387	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7388		ctx = rctx // use context from middleware stack in children
 7389		return obj.ClientMutationID, nil
 7390	})
 7391	if err != nil {
 7392		ec.Error(ctx, err)
 7393		return graphql.Null
 7394	}
 7395	if resTmp == nil {
 7396		return graphql.Null
 7397	}
 7398	res := resTmp.(*string)
 7399	fc.Result = res
 7400	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7401}
 7402
 7403func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (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:   "OpenBugPayload",
 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.Bug, 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.BugWrapper)
 7433	fc.Result = res
 7434	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7435}
 7436
 7437func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (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:   "OpenBugPayload",
 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.Operation, 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.SetStatusOperation)
 7467	fc.Result = res
 7468	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7469}
 7470
 7471func (ec *executionContext) _OperationConnection_edges(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.Edges, 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.OperationEdge)
 7501	fc.Result = res
 7502	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
 7503}
 7504
 7505func (ec *executionContext) _OperationConnection_nodes(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.Nodes, 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.([]bug.Operation)
 7535	fc.Result = res
 7536	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx, field.Selections, res)
 7537}
 7538
 7539func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (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:   "OperationConnection",
 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.PageInfo, 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.(*models.PageInfo)
 7569	fc.Result = res
 7570	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7571}
 7572
 7573func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (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:   "OperationConnection",
 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.TotalCount, 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.(int)
 7603	fc.Result = res
 7604	return ec.marshalNInt2int(ctx, field.Selections, res)
 7605}
 7606
 7607func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (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:   "OperationEdge",
 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.Cursor, 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.(string)
 7637	fc.Result = res
 7638	return ec.marshalNString2string(ctx, field.Selections, res)
 7639}
 7640
 7641func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (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:   "OperationEdge",
 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.Node, 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.(bug.Operation)
 7671	fc.Result = res
 7672	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7673}
 7674
 7675func (ec *executionContext) _PageInfo_hasNextPage(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.HasNextPage, 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.(bool)
 7705	fc.Result = res
 7706	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7707}
 7708
 7709func (ec *executionContext) _PageInfo_hasPreviousPage(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.HasPreviousPage, 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.(bool)
 7739	fc.Result = res
 7740	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7741}
 7742
 7743func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (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:   "PageInfo",
 7752		Field:    field,
 7753		Args:     nil,
 7754		IsMethod: false,
 7755	}
 7756
 7757	ctx = graphql.WithFieldContext(ctx, fc)
 7758	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7759		ctx = rctx // use context from middleware stack in children
 7760		return obj.StartCursor, nil
 7761	})
 7762	if err != nil {
 7763		ec.Error(ctx, err)
 7764		return graphql.Null
 7765	}
 7766	if resTmp == nil {
 7767		if !graphql.HasFieldError(ctx, fc) {
 7768			ec.Errorf(ctx, "must not be null")
 7769		}
 7770		return graphql.Null
 7771	}
 7772	res := resTmp.(string)
 7773	fc.Result = res
 7774	return ec.marshalNString2string(ctx, field.Selections, res)
 7775}
 7776
 7777func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7778	defer func() {
 7779		if r := recover(); r != nil {
 7780			ec.Error(ctx, ec.Recover(ctx, r))
 7781			ret = graphql.Null
 7782		}
 7783	}()
 7784	fc := &graphql.FieldContext{
 7785		Object:   "PageInfo",
 7786		Field:    field,
 7787		Args:     nil,
 7788		IsMethod: false,
 7789	}
 7790
 7791	ctx = graphql.WithFieldContext(ctx, fc)
 7792	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7793		ctx = rctx // use context from middleware stack in children
 7794		return obj.EndCursor, nil
 7795	})
 7796	if err != nil {
 7797		ec.Error(ctx, err)
 7798		return graphql.Null
 7799	}
 7800	if resTmp == nil {
 7801		if !graphql.HasFieldError(ctx, fc) {
 7802			ec.Errorf(ctx, "must not be null")
 7803		}
 7804		return graphql.Null
 7805	}
 7806	res := resTmp.(string)
 7807	fc.Result = res
 7808	return ec.marshalNString2string(ctx, field.Selections, res)
 7809}
 7810
 7811func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7812	defer func() {
 7813		if r := recover(); r != nil {
 7814			ec.Error(ctx, ec.Recover(ctx, r))
 7815			ret = graphql.Null
 7816		}
 7817	}()
 7818	fc := &graphql.FieldContext{
 7819		Object:   "Query",
 7820		Field:    field,
 7821		Args:     nil,
 7822		IsMethod: true,
 7823	}
 7824
 7825	ctx = graphql.WithFieldContext(ctx, fc)
 7826	rawArgs := field.ArgumentMap(ec.Variables)
 7827	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7828	if err != nil {
 7829		ec.Error(ctx, err)
 7830		return graphql.Null
 7831	}
 7832	fc.Args = args
 7833	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7834		ctx = rctx // use context from middleware stack in children
 7835		return ec.resolvers.Query().Repository(rctx, args["ref"].(*string))
 7836	})
 7837	if err != nil {
 7838		ec.Error(ctx, err)
 7839		return graphql.Null
 7840	}
 7841	if resTmp == nil {
 7842		return graphql.Null
 7843	}
 7844	res := resTmp.(*models.Repository)
 7845	fc.Result = res
 7846	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7847}
 7848
 7849func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7850	defer func() {
 7851		if r := recover(); r != nil {
 7852			ec.Error(ctx, ec.Recover(ctx, r))
 7853			ret = graphql.Null
 7854		}
 7855	}()
 7856	fc := &graphql.FieldContext{
 7857		Object:   "Query",
 7858		Field:    field,
 7859		Args:     nil,
 7860		IsMethod: true,
 7861	}
 7862
 7863	ctx = graphql.WithFieldContext(ctx, fc)
 7864	rawArgs := field.ArgumentMap(ec.Variables)
 7865	args, err := ec.field_Query___type_args(ctx, rawArgs)
 7866	if err != nil {
 7867		ec.Error(ctx, err)
 7868		return graphql.Null
 7869	}
 7870	fc.Args = args
 7871	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7872		ctx = rctx // use context from middleware stack in children
 7873		return ec.introspectType(args["name"].(string))
 7874	})
 7875	if err != nil {
 7876		ec.Error(ctx, err)
 7877		return graphql.Null
 7878	}
 7879	if resTmp == nil {
 7880		return graphql.Null
 7881	}
 7882	res := resTmp.(*introspection.Type)
 7883	fc.Result = res
 7884	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7885}
 7886
 7887func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7888	defer func() {
 7889		if r := recover(); r != nil {
 7890			ec.Error(ctx, ec.Recover(ctx, r))
 7891			ret = graphql.Null
 7892		}
 7893	}()
 7894	fc := &graphql.FieldContext{
 7895		Object:   "Query",
 7896		Field:    field,
 7897		Args:     nil,
 7898		IsMethod: true,
 7899	}
 7900
 7901	ctx = graphql.WithFieldContext(ctx, fc)
 7902	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7903		ctx = rctx // use context from middleware stack in children
 7904		return ec.introspectSchema()
 7905	})
 7906	if err != nil {
 7907		ec.Error(ctx, err)
 7908		return graphql.Null
 7909	}
 7910	if resTmp == nil {
 7911		return graphql.Null
 7912	}
 7913	res := resTmp.(*introspection.Schema)
 7914	fc.Result = res
 7915	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 7916}
 7917
 7918func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7919	defer func() {
 7920		if r := recover(); r != nil {
 7921			ec.Error(ctx, ec.Recover(ctx, r))
 7922			ret = graphql.Null
 7923		}
 7924	}()
 7925	fc := &graphql.FieldContext{
 7926		Object:   "Repository",
 7927		Field:    field,
 7928		Args:     nil,
 7929		IsMethod: true,
 7930	}
 7931
 7932	ctx = graphql.WithFieldContext(ctx, fc)
 7933	rawArgs := field.ArgumentMap(ec.Variables)
 7934	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 7935	if err != nil {
 7936		ec.Error(ctx, err)
 7937		return graphql.Null
 7938	}
 7939	fc.Args = args
 7940	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7941		ctx = rctx // use context from middleware stack in children
 7942		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 7943	})
 7944	if err != nil {
 7945		ec.Error(ctx, err)
 7946		return graphql.Null
 7947	}
 7948	if resTmp == nil {
 7949		if !graphql.HasFieldError(ctx, fc) {
 7950			ec.Errorf(ctx, "must not be null")
 7951		}
 7952		return graphql.Null
 7953	}
 7954	res := resTmp.(*models.BugConnection)
 7955	fc.Result = res
 7956	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 7957}
 7958
 7959func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7960	defer func() {
 7961		if r := recover(); r != nil {
 7962			ec.Error(ctx, ec.Recover(ctx, r))
 7963			ret = graphql.Null
 7964		}
 7965	}()
 7966	fc := &graphql.FieldContext{
 7967		Object:   "Repository",
 7968		Field:    field,
 7969		Args:     nil,
 7970		IsMethod: true,
 7971	}
 7972
 7973	ctx = graphql.WithFieldContext(ctx, fc)
 7974	rawArgs := field.ArgumentMap(ec.Variables)
 7975	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 7976	if err != nil {
 7977		ec.Error(ctx, err)
 7978		return graphql.Null
 7979	}
 7980	fc.Args = args
 7981	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7982		ctx = rctx // use context from middleware stack in children
 7983		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 7984	})
 7985	if err != nil {
 7986		ec.Error(ctx, err)
 7987		return graphql.Null
 7988	}
 7989	if resTmp == nil {
 7990		return graphql.Null
 7991	}
 7992	res := resTmp.(models.BugWrapper)
 7993	fc.Result = res
 7994	return ec.marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 7995}
 7996
 7997func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 7998	defer func() {
 7999		if r := recover(); r != nil {
 8000			ec.Error(ctx, ec.Recover(ctx, r))
 8001			ret = graphql.Null
 8002		}
 8003	}()
 8004	fc := &graphql.FieldContext{
 8005		Object:   "Repository",
 8006		Field:    field,
 8007		Args:     nil,
 8008		IsMethod: true,
 8009	}
 8010
 8011	ctx = graphql.WithFieldContext(ctx, fc)
 8012	rawArgs := field.ArgumentMap(ec.Variables)
 8013	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 8014	if err != nil {
 8015		ec.Error(ctx, err)
 8016		return graphql.Null
 8017	}
 8018	fc.Args = args
 8019	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8020		ctx = rctx // use context from middleware stack in children
 8021		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8022	})
 8023	if err != nil {
 8024		ec.Error(ctx, err)
 8025		return graphql.Null
 8026	}
 8027	if resTmp == nil {
 8028		if !graphql.HasFieldError(ctx, fc) {
 8029			ec.Errorf(ctx, "must not be null")
 8030		}
 8031		return graphql.Null
 8032	}
 8033	res := resTmp.(*models.IdentityConnection)
 8034	fc.Result = res
 8035	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 8036}
 8037
 8038func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8039	defer func() {
 8040		if r := recover(); r != nil {
 8041			ec.Error(ctx, ec.Recover(ctx, r))
 8042			ret = graphql.Null
 8043		}
 8044	}()
 8045	fc := &graphql.FieldContext{
 8046		Object:   "Repository",
 8047		Field:    field,
 8048		Args:     nil,
 8049		IsMethod: true,
 8050	}
 8051
 8052	ctx = graphql.WithFieldContext(ctx, fc)
 8053	rawArgs := field.ArgumentMap(ec.Variables)
 8054	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 8055	if err != nil {
 8056		ec.Error(ctx, err)
 8057		return graphql.Null
 8058	}
 8059	fc.Args = args
 8060	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8061		ctx = rctx // use context from middleware stack in children
 8062		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 8063	})
 8064	if err != nil {
 8065		ec.Error(ctx, err)
 8066		return graphql.Null
 8067	}
 8068	if resTmp == nil {
 8069		return graphql.Null
 8070	}
 8071	res := resTmp.(models.IdentityWrapper)
 8072	fc.Result = res
 8073	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8074}
 8075
 8076func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8077	defer func() {
 8078		if r := recover(); r != nil {
 8079			ec.Error(ctx, ec.Recover(ctx, r))
 8080			ret = graphql.Null
 8081		}
 8082	}()
 8083	fc := &graphql.FieldContext{
 8084		Object:   "Repository",
 8085		Field:    field,
 8086		Args:     nil,
 8087		IsMethod: true,
 8088	}
 8089
 8090	ctx = graphql.WithFieldContext(ctx, fc)
 8091	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8092		ctx = rctx // use context from middleware stack in children
 8093		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 8094	})
 8095	if err != nil {
 8096		ec.Error(ctx, err)
 8097		return graphql.Null
 8098	}
 8099	if resTmp == nil {
 8100		return graphql.Null
 8101	}
 8102	res := resTmp.(models.IdentityWrapper)
 8103	fc.Result = res
 8104	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8105}
 8106
 8107func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8108	defer func() {
 8109		if r := recover(); r != nil {
 8110			ec.Error(ctx, ec.Recover(ctx, r))
 8111			ret = graphql.Null
 8112		}
 8113	}()
 8114	fc := &graphql.FieldContext{
 8115		Object:   "Repository",
 8116		Field:    field,
 8117		Args:     nil,
 8118		IsMethod: true,
 8119	}
 8120
 8121	ctx = graphql.WithFieldContext(ctx, fc)
 8122	rawArgs := field.ArgumentMap(ec.Variables)
 8123	args, err := ec.field_Repository_validLabels_args(ctx, rawArgs)
 8124	if err != nil {
 8125		ec.Error(ctx, err)
 8126		return graphql.Null
 8127	}
 8128	fc.Args = args
 8129	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8130		ctx = rctx // use context from middleware stack in children
 8131		return ec.resolvers.Repository().ValidLabels(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8132	})
 8133	if err != nil {
 8134		ec.Error(ctx, err)
 8135		return graphql.Null
 8136	}
 8137	if resTmp == nil {
 8138		if !graphql.HasFieldError(ctx, fc) {
 8139			ec.Errorf(ctx, "must not be null")
 8140		}
 8141		return graphql.Null
 8142	}
 8143	res := resTmp.(*models.LabelConnection)
 8144	fc.Result = res
 8145	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 8146}
 8147
 8148func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8149	defer func() {
 8150		if r := recover(); r != nil {
 8151			ec.Error(ctx, ec.Recover(ctx, r))
 8152			ret = graphql.Null
 8153		}
 8154	}()
 8155	fc := &graphql.FieldContext{
 8156		Object:   "SetStatusOperation",
 8157		Field:    field,
 8158		Args:     nil,
 8159		IsMethod: true,
 8160	}
 8161
 8162	ctx = graphql.WithFieldContext(ctx, fc)
 8163	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8164		ctx = rctx // use context from middleware stack in children
 8165		return ec.resolvers.SetStatusOperation().ID(rctx, obj)
 8166	})
 8167	if err != nil {
 8168		ec.Error(ctx, err)
 8169		return graphql.Null
 8170	}
 8171	if resTmp == nil {
 8172		if !graphql.HasFieldError(ctx, fc) {
 8173			ec.Errorf(ctx, "must not be null")
 8174		}
 8175		return graphql.Null
 8176	}
 8177	res := resTmp.(string)
 8178	fc.Result = res
 8179	return ec.marshalNString2string(ctx, field.Selections, res)
 8180}
 8181
 8182func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8183	defer func() {
 8184		if r := recover(); r != nil {
 8185			ec.Error(ctx, ec.Recover(ctx, r))
 8186			ret = graphql.Null
 8187		}
 8188	}()
 8189	fc := &graphql.FieldContext{
 8190		Object:   "SetStatusOperation",
 8191		Field:    field,
 8192		Args:     nil,
 8193		IsMethod: true,
 8194	}
 8195
 8196	ctx = graphql.WithFieldContext(ctx, fc)
 8197	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8198		ctx = rctx // use context from middleware stack in children
 8199		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
 8200	})
 8201	if err != nil {
 8202		ec.Error(ctx, err)
 8203		return graphql.Null
 8204	}
 8205	if resTmp == nil {
 8206		if !graphql.HasFieldError(ctx, fc) {
 8207			ec.Errorf(ctx, "must not be null")
 8208		}
 8209		return graphql.Null
 8210	}
 8211	res := resTmp.(models.IdentityWrapper)
 8212	fc.Result = res
 8213	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8214}
 8215
 8216func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8217	defer func() {
 8218		if r := recover(); r != nil {
 8219			ec.Error(ctx, ec.Recover(ctx, r))
 8220			ret = graphql.Null
 8221		}
 8222	}()
 8223	fc := &graphql.FieldContext{
 8224		Object:   "SetStatusOperation",
 8225		Field:    field,
 8226		Args:     nil,
 8227		IsMethod: true,
 8228	}
 8229
 8230	ctx = graphql.WithFieldContext(ctx, fc)
 8231	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8232		ctx = rctx // use context from middleware stack in children
 8233		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 8234	})
 8235	if err != nil {
 8236		ec.Error(ctx, err)
 8237		return graphql.Null
 8238	}
 8239	if resTmp == nil {
 8240		if !graphql.HasFieldError(ctx, fc) {
 8241			ec.Errorf(ctx, "must not be null")
 8242		}
 8243		return graphql.Null
 8244	}
 8245	res := resTmp.(*time.Time)
 8246	fc.Result = res
 8247	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8248}
 8249
 8250func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8251	defer func() {
 8252		if r := recover(); r != nil {
 8253			ec.Error(ctx, ec.Recover(ctx, r))
 8254			ret = graphql.Null
 8255		}
 8256	}()
 8257	fc := &graphql.FieldContext{
 8258		Object:   "SetStatusOperation",
 8259		Field:    field,
 8260		Args:     nil,
 8261		IsMethod: true,
 8262	}
 8263
 8264	ctx = graphql.WithFieldContext(ctx, fc)
 8265	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8266		ctx = rctx // use context from middleware stack in children
 8267		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8268	})
 8269	if err != nil {
 8270		ec.Error(ctx, err)
 8271		return graphql.Null
 8272	}
 8273	if resTmp == nil {
 8274		if !graphql.HasFieldError(ctx, fc) {
 8275			ec.Errorf(ctx, "must not be null")
 8276		}
 8277		return graphql.Null
 8278	}
 8279	res := resTmp.(models.Status)
 8280	fc.Result = res
 8281	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8282}
 8283
 8284func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8285	defer func() {
 8286		if r := recover(); r != nil {
 8287			ec.Error(ctx, ec.Recover(ctx, r))
 8288			ret = graphql.Null
 8289		}
 8290	}()
 8291	fc := &graphql.FieldContext{
 8292		Object:   "SetStatusTimelineItem",
 8293		Field:    field,
 8294		Args:     nil,
 8295		IsMethod: true,
 8296	}
 8297
 8298	ctx = graphql.WithFieldContext(ctx, fc)
 8299	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8300		ctx = rctx // use context from middleware stack in children
 8301		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
 8302	})
 8303	if err != nil {
 8304		ec.Error(ctx, err)
 8305		return graphql.Null
 8306	}
 8307	if resTmp == nil {
 8308		if !graphql.HasFieldError(ctx, fc) {
 8309			ec.Errorf(ctx, "must not be null")
 8310		}
 8311		return graphql.Null
 8312	}
 8313	res := resTmp.(string)
 8314	fc.Result = res
 8315	return ec.marshalNString2string(ctx, field.Selections, res)
 8316}
 8317
 8318func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8319	defer func() {
 8320		if r := recover(); r != nil {
 8321			ec.Error(ctx, ec.Recover(ctx, r))
 8322			ret = graphql.Null
 8323		}
 8324	}()
 8325	fc := &graphql.FieldContext{
 8326		Object:   "SetStatusTimelineItem",
 8327		Field:    field,
 8328		Args:     nil,
 8329		IsMethod: true,
 8330	}
 8331
 8332	ctx = graphql.WithFieldContext(ctx, fc)
 8333	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8334		ctx = rctx // use context from middleware stack in children
 8335		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
 8336	})
 8337	if err != nil {
 8338		ec.Error(ctx, err)
 8339		return graphql.Null
 8340	}
 8341	if resTmp == nil {
 8342		if !graphql.HasFieldError(ctx, fc) {
 8343			ec.Errorf(ctx, "must not be null")
 8344		}
 8345		return graphql.Null
 8346	}
 8347	res := resTmp.(models.IdentityWrapper)
 8348	fc.Result = res
 8349	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8350}
 8351
 8352func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8353	defer func() {
 8354		if r := recover(); r != nil {
 8355			ec.Error(ctx, ec.Recover(ctx, r))
 8356			ret = graphql.Null
 8357		}
 8358	}()
 8359	fc := &graphql.FieldContext{
 8360		Object:   "SetStatusTimelineItem",
 8361		Field:    field,
 8362		Args:     nil,
 8363		IsMethod: true,
 8364	}
 8365
 8366	ctx = graphql.WithFieldContext(ctx, fc)
 8367	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8368		ctx = rctx // use context from middleware stack in children
 8369		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8370	})
 8371	if err != nil {
 8372		ec.Error(ctx, err)
 8373		return graphql.Null
 8374	}
 8375	if resTmp == nil {
 8376		if !graphql.HasFieldError(ctx, fc) {
 8377			ec.Errorf(ctx, "must not be null")
 8378		}
 8379		return graphql.Null
 8380	}
 8381	res := resTmp.(*time.Time)
 8382	fc.Result = res
 8383	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8384}
 8385
 8386func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8387	defer func() {
 8388		if r := recover(); r != nil {
 8389			ec.Error(ctx, ec.Recover(ctx, r))
 8390			ret = graphql.Null
 8391		}
 8392	}()
 8393	fc := &graphql.FieldContext{
 8394		Object:   "SetStatusTimelineItem",
 8395		Field:    field,
 8396		Args:     nil,
 8397		IsMethod: true,
 8398	}
 8399
 8400	ctx = graphql.WithFieldContext(ctx, fc)
 8401	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8402		ctx = rctx // use context from middleware stack in children
 8403		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8404	})
 8405	if err != nil {
 8406		ec.Error(ctx, err)
 8407		return graphql.Null
 8408	}
 8409	if resTmp == nil {
 8410		if !graphql.HasFieldError(ctx, fc) {
 8411			ec.Errorf(ctx, "must not be null")
 8412		}
 8413		return graphql.Null
 8414	}
 8415	res := resTmp.(models.Status)
 8416	fc.Result = res
 8417	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8418}
 8419
 8420func (ec *executionContext) _SetTitleOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8421	defer func() {
 8422		if r := recover(); r != nil {
 8423			ec.Error(ctx, ec.Recover(ctx, r))
 8424			ret = graphql.Null
 8425		}
 8426	}()
 8427	fc := &graphql.FieldContext{
 8428		Object:   "SetTitleOperation",
 8429		Field:    field,
 8430		Args:     nil,
 8431		IsMethod: true,
 8432	}
 8433
 8434	ctx = graphql.WithFieldContext(ctx, fc)
 8435	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8436		ctx = rctx // use context from middleware stack in children
 8437		return ec.resolvers.SetTitleOperation().ID(rctx, obj)
 8438	})
 8439	if err != nil {
 8440		ec.Error(ctx, err)
 8441		return graphql.Null
 8442	}
 8443	if resTmp == nil {
 8444		if !graphql.HasFieldError(ctx, fc) {
 8445			ec.Errorf(ctx, "must not be null")
 8446		}
 8447		return graphql.Null
 8448	}
 8449	res := resTmp.(string)
 8450	fc.Result = res
 8451	return ec.marshalNString2string(ctx, field.Selections, res)
 8452}
 8453
 8454func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8455	defer func() {
 8456		if r := recover(); r != nil {
 8457			ec.Error(ctx, ec.Recover(ctx, r))
 8458			ret = graphql.Null
 8459		}
 8460	}()
 8461	fc := &graphql.FieldContext{
 8462		Object:   "SetTitleOperation",
 8463		Field:    field,
 8464		Args:     nil,
 8465		IsMethod: true,
 8466	}
 8467
 8468	ctx = graphql.WithFieldContext(ctx, fc)
 8469	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8470		ctx = rctx // use context from middleware stack in children
 8471		return ec.resolvers.SetTitleOperation().Author(rctx, obj)
 8472	})
 8473	if err != nil {
 8474		ec.Error(ctx, err)
 8475		return graphql.Null
 8476	}
 8477	if resTmp == nil {
 8478		if !graphql.HasFieldError(ctx, fc) {
 8479			ec.Errorf(ctx, "must not be null")
 8480		}
 8481		return graphql.Null
 8482	}
 8483	res := resTmp.(models.IdentityWrapper)
 8484	fc.Result = res
 8485	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8486}
 8487
 8488func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8489	defer func() {
 8490		if r := recover(); r != nil {
 8491			ec.Error(ctx, ec.Recover(ctx, r))
 8492			ret = graphql.Null
 8493		}
 8494	}()
 8495	fc := &graphql.FieldContext{
 8496		Object:   "SetTitleOperation",
 8497		Field:    field,
 8498		Args:     nil,
 8499		IsMethod: true,
 8500	}
 8501
 8502	ctx = graphql.WithFieldContext(ctx, fc)
 8503	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8504		ctx = rctx // use context from middleware stack in children
 8505		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8506	})
 8507	if err != nil {
 8508		ec.Error(ctx, err)
 8509		return graphql.Null
 8510	}
 8511	if resTmp == nil {
 8512		if !graphql.HasFieldError(ctx, fc) {
 8513			ec.Errorf(ctx, "must not be null")
 8514		}
 8515		return graphql.Null
 8516	}
 8517	res := resTmp.(*time.Time)
 8518	fc.Result = res
 8519	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8520}
 8521
 8522func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8523	defer func() {
 8524		if r := recover(); r != nil {
 8525			ec.Error(ctx, ec.Recover(ctx, r))
 8526			ret = graphql.Null
 8527		}
 8528	}()
 8529	fc := &graphql.FieldContext{
 8530		Object:   "SetTitleOperation",
 8531		Field:    field,
 8532		Args:     nil,
 8533		IsMethod: false,
 8534	}
 8535
 8536	ctx = graphql.WithFieldContext(ctx, fc)
 8537	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8538		ctx = rctx // use context from middleware stack in children
 8539		return obj.Title, nil
 8540	})
 8541	if err != nil {
 8542		ec.Error(ctx, err)
 8543		return graphql.Null
 8544	}
 8545	if resTmp == nil {
 8546		if !graphql.HasFieldError(ctx, fc) {
 8547			ec.Errorf(ctx, "must not be null")
 8548		}
 8549		return graphql.Null
 8550	}
 8551	res := resTmp.(string)
 8552	fc.Result = res
 8553	return ec.marshalNString2string(ctx, field.Selections, res)
 8554}
 8555
 8556func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8557	defer func() {
 8558		if r := recover(); r != nil {
 8559			ec.Error(ctx, ec.Recover(ctx, r))
 8560			ret = graphql.Null
 8561		}
 8562	}()
 8563	fc := &graphql.FieldContext{
 8564		Object:   "SetTitleOperation",
 8565		Field:    field,
 8566		Args:     nil,
 8567		IsMethod: false,
 8568	}
 8569
 8570	ctx = graphql.WithFieldContext(ctx, fc)
 8571	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8572		ctx = rctx // use context from middleware stack in children
 8573		return obj.Was, nil
 8574	})
 8575	if err != nil {
 8576		ec.Error(ctx, err)
 8577		return graphql.Null
 8578	}
 8579	if resTmp == nil {
 8580		if !graphql.HasFieldError(ctx, fc) {
 8581			ec.Errorf(ctx, "must not be null")
 8582		}
 8583		return graphql.Null
 8584	}
 8585	res := resTmp.(string)
 8586	fc.Result = res
 8587	return ec.marshalNString2string(ctx, field.Selections, res)
 8588}
 8589
 8590func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8591	defer func() {
 8592		if r := recover(); r != nil {
 8593			ec.Error(ctx, ec.Recover(ctx, r))
 8594			ret = graphql.Null
 8595		}
 8596	}()
 8597	fc := &graphql.FieldContext{
 8598		Object:   "SetTitlePayload",
 8599		Field:    field,
 8600		Args:     nil,
 8601		IsMethod: false,
 8602	}
 8603
 8604	ctx = graphql.WithFieldContext(ctx, fc)
 8605	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8606		ctx = rctx // use context from middleware stack in children
 8607		return obj.ClientMutationID, nil
 8608	})
 8609	if err != nil {
 8610		ec.Error(ctx, err)
 8611		return graphql.Null
 8612	}
 8613	if resTmp == nil {
 8614		return graphql.Null
 8615	}
 8616	res := resTmp.(*string)
 8617	fc.Result = res
 8618	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8619}
 8620
 8621func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8622	defer func() {
 8623		if r := recover(); r != nil {
 8624			ec.Error(ctx, ec.Recover(ctx, r))
 8625			ret = graphql.Null
 8626		}
 8627	}()
 8628	fc := &graphql.FieldContext{
 8629		Object:   "SetTitlePayload",
 8630		Field:    field,
 8631		Args:     nil,
 8632		IsMethod: false,
 8633	}
 8634
 8635	ctx = graphql.WithFieldContext(ctx, fc)
 8636	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8637		ctx = rctx // use context from middleware stack in children
 8638		return obj.Bug, nil
 8639	})
 8640	if err != nil {
 8641		ec.Error(ctx, err)
 8642		return graphql.Null
 8643	}
 8644	if resTmp == nil {
 8645		if !graphql.HasFieldError(ctx, fc) {
 8646			ec.Errorf(ctx, "must not be null")
 8647		}
 8648		return graphql.Null
 8649	}
 8650	res := resTmp.(models.BugWrapper)
 8651	fc.Result = res
 8652	return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 8653}
 8654
 8655func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8656	defer func() {
 8657		if r := recover(); r != nil {
 8658			ec.Error(ctx, ec.Recover(ctx, r))
 8659			ret = graphql.Null
 8660		}
 8661	}()
 8662	fc := &graphql.FieldContext{
 8663		Object:   "SetTitlePayload",
 8664		Field:    field,
 8665		Args:     nil,
 8666		IsMethod: false,
 8667	}
 8668
 8669	ctx = graphql.WithFieldContext(ctx, fc)
 8670	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8671		ctx = rctx // use context from middleware stack in children
 8672		return obj.Operation, nil
 8673	})
 8674	if err != nil {
 8675		ec.Error(ctx, err)
 8676		return graphql.Null
 8677	}
 8678	if resTmp == nil {
 8679		if !graphql.HasFieldError(ctx, fc) {
 8680			ec.Errorf(ctx, "must not be null")
 8681		}
 8682		return graphql.Null
 8683	}
 8684	res := resTmp.(*bug.SetTitleOperation)
 8685	fc.Result = res
 8686	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8687}
 8688
 8689func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8690	defer func() {
 8691		if r := recover(); r != nil {
 8692			ec.Error(ctx, ec.Recover(ctx, r))
 8693			ret = graphql.Null
 8694		}
 8695	}()
 8696	fc := &graphql.FieldContext{
 8697		Object:   "SetTitleTimelineItem",
 8698		Field:    field,
 8699		Args:     nil,
 8700		IsMethod: true,
 8701	}
 8702
 8703	ctx = graphql.WithFieldContext(ctx, fc)
 8704	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8705		ctx = rctx // use context from middleware stack in children
 8706		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
 8707	})
 8708	if err != nil {
 8709		ec.Error(ctx, err)
 8710		return graphql.Null
 8711	}
 8712	if resTmp == nil {
 8713		if !graphql.HasFieldError(ctx, fc) {
 8714			ec.Errorf(ctx, "must not be null")
 8715		}
 8716		return graphql.Null
 8717	}
 8718	res := resTmp.(string)
 8719	fc.Result = res
 8720	return ec.marshalNString2string(ctx, field.Selections, res)
 8721}
 8722
 8723func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8724	defer func() {
 8725		if r := recover(); r != nil {
 8726			ec.Error(ctx, ec.Recover(ctx, r))
 8727			ret = graphql.Null
 8728		}
 8729	}()
 8730	fc := &graphql.FieldContext{
 8731		Object:   "SetTitleTimelineItem",
 8732		Field:    field,
 8733		Args:     nil,
 8734		IsMethod: true,
 8735	}
 8736
 8737	ctx = graphql.WithFieldContext(ctx, fc)
 8738	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8739		ctx = rctx // use context from middleware stack in children
 8740		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
 8741	})
 8742	if err != nil {
 8743		ec.Error(ctx, err)
 8744		return graphql.Null
 8745	}
 8746	if resTmp == nil {
 8747		if !graphql.HasFieldError(ctx, fc) {
 8748			ec.Errorf(ctx, "must not be null")
 8749		}
 8750		return graphql.Null
 8751	}
 8752	res := resTmp.(models.IdentityWrapper)
 8753	fc.Result = res
 8754	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 8755}
 8756
 8757func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8758	defer func() {
 8759		if r := recover(); r != nil {
 8760			ec.Error(ctx, ec.Recover(ctx, r))
 8761			ret = graphql.Null
 8762		}
 8763	}()
 8764	fc := &graphql.FieldContext{
 8765		Object:   "SetTitleTimelineItem",
 8766		Field:    field,
 8767		Args:     nil,
 8768		IsMethod: true,
 8769	}
 8770
 8771	ctx = graphql.WithFieldContext(ctx, fc)
 8772	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8773		ctx = rctx // use context from middleware stack in children
 8774		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8775	})
 8776	if err != nil {
 8777		ec.Error(ctx, err)
 8778		return graphql.Null
 8779	}
 8780	if resTmp == nil {
 8781		if !graphql.HasFieldError(ctx, fc) {
 8782			ec.Errorf(ctx, "must not be null")
 8783		}
 8784		return graphql.Null
 8785	}
 8786	res := resTmp.(*time.Time)
 8787	fc.Result = res
 8788	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8789}
 8790
 8791func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8792	defer func() {
 8793		if r := recover(); r != nil {
 8794			ec.Error(ctx, ec.Recover(ctx, r))
 8795			ret = graphql.Null
 8796		}
 8797	}()
 8798	fc := &graphql.FieldContext{
 8799		Object:   "SetTitleTimelineItem",
 8800		Field:    field,
 8801		Args:     nil,
 8802		IsMethod: false,
 8803	}
 8804
 8805	ctx = graphql.WithFieldContext(ctx, fc)
 8806	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8807		ctx = rctx // use context from middleware stack in children
 8808		return obj.Title, nil
 8809	})
 8810	if err != nil {
 8811		ec.Error(ctx, err)
 8812		return graphql.Null
 8813	}
 8814	if resTmp == nil {
 8815		if !graphql.HasFieldError(ctx, fc) {
 8816			ec.Errorf(ctx, "must not be null")
 8817		}
 8818		return graphql.Null
 8819	}
 8820	res := resTmp.(string)
 8821	fc.Result = res
 8822	return ec.marshalNString2string(ctx, field.Selections, res)
 8823}
 8824
 8825func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8826	defer func() {
 8827		if r := recover(); r != nil {
 8828			ec.Error(ctx, ec.Recover(ctx, r))
 8829			ret = graphql.Null
 8830		}
 8831	}()
 8832	fc := &graphql.FieldContext{
 8833		Object:   "SetTitleTimelineItem",
 8834		Field:    field,
 8835		Args:     nil,
 8836		IsMethod: false,
 8837	}
 8838
 8839	ctx = graphql.WithFieldContext(ctx, fc)
 8840	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8841		ctx = rctx // use context from middleware stack in children
 8842		return obj.Was, nil
 8843	})
 8844	if err != nil {
 8845		ec.Error(ctx, err)
 8846		return graphql.Null
 8847	}
 8848	if resTmp == nil {
 8849		if !graphql.HasFieldError(ctx, fc) {
 8850			ec.Errorf(ctx, "must not be null")
 8851		}
 8852		return graphql.Null
 8853	}
 8854	res := resTmp.(string)
 8855	fc.Result = res
 8856	return ec.marshalNString2string(ctx, field.Selections, res)
 8857}
 8858
 8859func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8860	defer func() {
 8861		if r := recover(); r != nil {
 8862			ec.Error(ctx, ec.Recover(ctx, r))
 8863			ret = graphql.Null
 8864		}
 8865	}()
 8866	fc := &graphql.FieldContext{
 8867		Object:   "TimelineItemConnection",
 8868		Field:    field,
 8869		Args:     nil,
 8870		IsMethod: false,
 8871	}
 8872
 8873	ctx = graphql.WithFieldContext(ctx, fc)
 8874	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8875		ctx = rctx // use context from middleware stack in children
 8876		return obj.Edges, nil
 8877	})
 8878	if err != nil {
 8879		ec.Error(ctx, err)
 8880		return graphql.Null
 8881	}
 8882	if resTmp == nil {
 8883		if !graphql.HasFieldError(ctx, fc) {
 8884			ec.Errorf(ctx, "must not be null")
 8885		}
 8886		return graphql.Null
 8887	}
 8888	res := resTmp.([]*models.TimelineItemEdge)
 8889	fc.Result = res
 8890	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx, field.Selections, res)
 8891}
 8892
 8893func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8894	defer func() {
 8895		if r := recover(); r != nil {
 8896			ec.Error(ctx, ec.Recover(ctx, r))
 8897			ret = graphql.Null
 8898		}
 8899	}()
 8900	fc := &graphql.FieldContext{
 8901		Object:   "TimelineItemConnection",
 8902		Field:    field,
 8903		Args:     nil,
 8904		IsMethod: false,
 8905	}
 8906
 8907	ctx = graphql.WithFieldContext(ctx, fc)
 8908	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8909		ctx = rctx // use context from middleware stack in children
 8910		return obj.Nodes, nil
 8911	})
 8912	if err != nil {
 8913		ec.Error(ctx, err)
 8914		return graphql.Null
 8915	}
 8916	if resTmp == nil {
 8917		if !graphql.HasFieldError(ctx, fc) {
 8918			ec.Errorf(ctx, "must not be null")
 8919		}
 8920		return graphql.Null
 8921	}
 8922	res := resTmp.([]bug.TimelineItem)
 8923	fc.Result = res
 8924	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx, field.Selections, res)
 8925}
 8926
 8927func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8928	defer func() {
 8929		if r := recover(); r != nil {
 8930			ec.Error(ctx, ec.Recover(ctx, r))
 8931			ret = graphql.Null
 8932		}
 8933	}()
 8934	fc := &graphql.FieldContext{
 8935		Object:   "TimelineItemConnection",
 8936		Field:    field,
 8937		Args:     nil,
 8938		IsMethod: false,
 8939	}
 8940
 8941	ctx = graphql.WithFieldContext(ctx, fc)
 8942	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8943		ctx = rctx // use context from middleware stack in children
 8944		return obj.PageInfo, nil
 8945	})
 8946	if err != nil {
 8947		ec.Error(ctx, err)
 8948		return graphql.Null
 8949	}
 8950	if resTmp == nil {
 8951		if !graphql.HasFieldError(ctx, fc) {
 8952			ec.Errorf(ctx, "must not be null")
 8953		}
 8954		return graphql.Null
 8955	}
 8956	res := resTmp.(*models.PageInfo)
 8957	fc.Result = res
 8958	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 8959}
 8960
 8961func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 8962	defer func() {
 8963		if r := recover(); r != nil {
 8964			ec.Error(ctx, ec.Recover(ctx, r))
 8965			ret = graphql.Null
 8966		}
 8967	}()
 8968	fc := &graphql.FieldContext{
 8969		Object:   "TimelineItemConnection",
 8970		Field:    field,
 8971		Args:     nil,
 8972		IsMethod: false,
 8973	}
 8974
 8975	ctx = graphql.WithFieldContext(ctx, fc)
 8976	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8977		ctx = rctx // use context from middleware stack in children
 8978		return obj.TotalCount, nil
 8979	})
 8980	if err != nil {
 8981		ec.Error(ctx, err)
 8982		return graphql.Null
 8983	}
 8984	if resTmp == nil {
 8985		if !graphql.HasFieldError(ctx, fc) {
 8986			ec.Errorf(ctx, "must not be null")
 8987		}
 8988		return graphql.Null
 8989	}
 8990	res := resTmp.(int)
 8991	fc.Result = res
 8992	return ec.marshalNInt2int(ctx, field.Selections, res)
 8993}
 8994
 8995func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 8996	defer func() {
 8997		if r := recover(); r != nil {
 8998			ec.Error(ctx, ec.Recover(ctx, r))
 8999			ret = graphql.Null
 9000		}
 9001	}()
 9002	fc := &graphql.FieldContext{
 9003		Object:   "TimelineItemEdge",
 9004		Field:    field,
 9005		Args:     nil,
 9006		IsMethod: false,
 9007	}
 9008
 9009	ctx = graphql.WithFieldContext(ctx, fc)
 9010	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9011		ctx = rctx // use context from middleware stack in children
 9012		return obj.Cursor, nil
 9013	})
 9014	if err != nil {
 9015		ec.Error(ctx, err)
 9016		return graphql.Null
 9017	}
 9018	if resTmp == nil {
 9019		if !graphql.HasFieldError(ctx, fc) {
 9020			ec.Errorf(ctx, "must not be null")
 9021		}
 9022		return graphql.Null
 9023	}
 9024	res := resTmp.(string)
 9025	fc.Result = res
 9026	return ec.marshalNString2string(ctx, field.Selections, res)
 9027}
 9028
 9029func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 9030	defer func() {
 9031		if r := recover(); r != nil {
 9032			ec.Error(ctx, ec.Recover(ctx, r))
 9033			ret = graphql.Null
 9034		}
 9035	}()
 9036	fc := &graphql.FieldContext{
 9037		Object:   "TimelineItemEdge",
 9038		Field:    field,
 9039		Args:     nil,
 9040		IsMethod: false,
 9041	}
 9042
 9043	ctx = graphql.WithFieldContext(ctx, fc)
 9044	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9045		ctx = rctx // use context from middleware stack in children
 9046		return obj.Node, nil
 9047	})
 9048	if err != nil {
 9049		ec.Error(ctx, err)
 9050		return graphql.Null
 9051	}
 9052	if resTmp == nil {
 9053		if !graphql.HasFieldError(ctx, fc) {
 9054			ec.Errorf(ctx, "must not be null")
 9055		}
 9056		return graphql.Null
 9057	}
 9058	res := resTmp.(bug.TimelineItem)
 9059	fc.Result = res
 9060	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 9061}
 9062
 9063func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9064	defer func() {
 9065		if r := recover(); r != nil {
 9066			ec.Error(ctx, ec.Recover(ctx, r))
 9067			ret = graphql.Null
 9068		}
 9069	}()
 9070	fc := &graphql.FieldContext{
 9071		Object:   "__Directive",
 9072		Field:    field,
 9073		Args:     nil,
 9074		IsMethod: false,
 9075	}
 9076
 9077	ctx = graphql.WithFieldContext(ctx, fc)
 9078	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9079		ctx = rctx // use context from middleware stack in children
 9080		return obj.Name, nil
 9081	})
 9082	if err != nil {
 9083		ec.Error(ctx, err)
 9084		return graphql.Null
 9085	}
 9086	if resTmp == nil {
 9087		if !graphql.HasFieldError(ctx, fc) {
 9088			ec.Errorf(ctx, "must not be null")
 9089		}
 9090		return graphql.Null
 9091	}
 9092	res := resTmp.(string)
 9093	fc.Result = res
 9094	return ec.marshalNString2string(ctx, field.Selections, res)
 9095}
 9096
 9097func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9098	defer func() {
 9099		if r := recover(); r != nil {
 9100			ec.Error(ctx, ec.Recover(ctx, r))
 9101			ret = graphql.Null
 9102		}
 9103	}()
 9104	fc := &graphql.FieldContext{
 9105		Object:   "__Directive",
 9106		Field:    field,
 9107		Args:     nil,
 9108		IsMethod: false,
 9109	}
 9110
 9111	ctx = graphql.WithFieldContext(ctx, fc)
 9112	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9113		ctx = rctx // use context from middleware stack in children
 9114		return obj.Description, nil
 9115	})
 9116	if err != nil {
 9117		ec.Error(ctx, err)
 9118		return graphql.Null
 9119	}
 9120	if resTmp == nil {
 9121		return graphql.Null
 9122	}
 9123	res := resTmp.(string)
 9124	fc.Result = res
 9125	return ec.marshalOString2string(ctx, field.Selections, res)
 9126}
 9127
 9128func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9129	defer func() {
 9130		if r := recover(); r != nil {
 9131			ec.Error(ctx, ec.Recover(ctx, r))
 9132			ret = graphql.Null
 9133		}
 9134	}()
 9135	fc := &graphql.FieldContext{
 9136		Object:   "__Directive",
 9137		Field:    field,
 9138		Args:     nil,
 9139		IsMethod: false,
 9140	}
 9141
 9142	ctx = graphql.WithFieldContext(ctx, fc)
 9143	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9144		ctx = rctx // use context from middleware stack in children
 9145		return obj.Locations, nil
 9146	})
 9147	if err != nil {
 9148		ec.Error(ctx, err)
 9149		return graphql.Null
 9150	}
 9151	if resTmp == nil {
 9152		if !graphql.HasFieldError(ctx, fc) {
 9153			ec.Errorf(ctx, "must not be null")
 9154		}
 9155		return graphql.Null
 9156	}
 9157	res := resTmp.([]string)
 9158	fc.Result = res
 9159	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 9160}
 9161
 9162func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9163	defer func() {
 9164		if r := recover(); r != nil {
 9165			ec.Error(ctx, ec.Recover(ctx, r))
 9166			ret = graphql.Null
 9167		}
 9168	}()
 9169	fc := &graphql.FieldContext{
 9170		Object:   "__Directive",
 9171		Field:    field,
 9172		Args:     nil,
 9173		IsMethod: false,
 9174	}
 9175
 9176	ctx = graphql.WithFieldContext(ctx, fc)
 9177	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9178		ctx = rctx // use context from middleware stack in children
 9179		return obj.Args, nil
 9180	})
 9181	if err != nil {
 9182		ec.Error(ctx, err)
 9183		return graphql.Null
 9184	}
 9185	if resTmp == nil {
 9186		if !graphql.HasFieldError(ctx, fc) {
 9187			ec.Errorf(ctx, "must not be null")
 9188		}
 9189		return graphql.Null
 9190	}
 9191	res := resTmp.([]introspection.InputValue)
 9192	fc.Result = res
 9193	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9194}
 9195
 9196func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9197	defer func() {
 9198		if r := recover(); r != nil {
 9199			ec.Error(ctx, ec.Recover(ctx, r))
 9200			ret = graphql.Null
 9201		}
 9202	}()
 9203	fc := &graphql.FieldContext{
 9204		Object:   "__EnumValue",
 9205		Field:    field,
 9206		Args:     nil,
 9207		IsMethod: false,
 9208	}
 9209
 9210	ctx = graphql.WithFieldContext(ctx, fc)
 9211	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9212		ctx = rctx // use context from middleware stack in children
 9213		return obj.Name, nil
 9214	})
 9215	if err != nil {
 9216		ec.Error(ctx, err)
 9217		return graphql.Null
 9218	}
 9219	if resTmp == nil {
 9220		if !graphql.HasFieldError(ctx, fc) {
 9221			ec.Errorf(ctx, "must not be null")
 9222		}
 9223		return graphql.Null
 9224	}
 9225	res := resTmp.(string)
 9226	fc.Result = res
 9227	return ec.marshalNString2string(ctx, field.Selections, res)
 9228}
 9229
 9230func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9231	defer func() {
 9232		if r := recover(); r != nil {
 9233			ec.Error(ctx, ec.Recover(ctx, r))
 9234			ret = graphql.Null
 9235		}
 9236	}()
 9237	fc := &graphql.FieldContext{
 9238		Object:   "__EnumValue",
 9239		Field:    field,
 9240		Args:     nil,
 9241		IsMethod: false,
 9242	}
 9243
 9244	ctx = graphql.WithFieldContext(ctx, fc)
 9245	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9246		ctx = rctx // use context from middleware stack in children
 9247		return obj.Description, nil
 9248	})
 9249	if err != nil {
 9250		ec.Error(ctx, err)
 9251		return graphql.Null
 9252	}
 9253	if resTmp == nil {
 9254		return graphql.Null
 9255	}
 9256	res := resTmp.(string)
 9257	fc.Result = res
 9258	return ec.marshalOString2string(ctx, field.Selections, res)
 9259}
 9260
 9261func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9262	defer func() {
 9263		if r := recover(); r != nil {
 9264			ec.Error(ctx, ec.Recover(ctx, r))
 9265			ret = graphql.Null
 9266		}
 9267	}()
 9268	fc := &graphql.FieldContext{
 9269		Object:   "__EnumValue",
 9270		Field:    field,
 9271		Args:     nil,
 9272		IsMethod: true,
 9273	}
 9274
 9275	ctx = graphql.WithFieldContext(ctx, fc)
 9276	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9277		ctx = rctx // use context from middleware stack in children
 9278		return obj.IsDeprecated(), nil
 9279	})
 9280	if err != nil {
 9281		ec.Error(ctx, err)
 9282		return graphql.Null
 9283	}
 9284	if resTmp == nil {
 9285		if !graphql.HasFieldError(ctx, fc) {
 9286			ec.Errorf(ctx, "must not be null")
 9287		}
 9288		return graphql.Null
 9289	}
 9290	res := resTmp.(bool)
 9291	fc.Result = res
 9292	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9293}
 9294
 9295func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9296	defer func() {
 9297		if r := recover(); r != nil {
 9298			ec.Error(ctx, ec.Recover(ctx, r))
 9299			ret = graphql.Null
 9300		}
 9301	}()
 9302	fc := &graphql.FieldContext{
 9303		Object:   "__EnumValue",
 9304		Field:    field,
 9305		Args:     nil,
 9306		IsMethod: true,
 9307	}
 9308
 9309	ctx = graphql.WithFieldContext(ctx, fc)
 9310	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9311		ctx = rctx // use context from middleware stack in children
 9312		return obj.DeprecationReason(), nil
 9313	})
 9314	if err != nil {
 9315		ec.Error(ctx, err)
 9316		return graphql.Null
 9317	}
 9318	if resTmp == nil {
 9319		return graphql.Null
 9320	}
 9321	res := resTmp.(*string)
 9322	fc.Result = res
 9323	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9324}
 9325
 9326func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9327	defer func() {
 9328		if r := recover(); r != nil {
 9329			ec.Error(ctx, ec.Recover(ctx, r))
 9330			ret = graphql.Null
 9331		}
 9332	}()
 9333	fc := &graphql.FieldContext{
 9334		Object:   "__Field",
 9335		Field:    field,
 9336		Args:     nil,
 9337		IsMethod: false,
 9338	}
 9339
 9340	ctx = graphql.WithFieldContext(ctx, fc)
 9341	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9342		ctx = rctx // use context from middleware stack in children
 9343		return obj.Name, nil
 9344	})
 9345	if err != nil {
 9346		ec.Error(ctx, err)
 9347		return graphql.Null
 9348	}
 9349	if resTmp == nil {
 9350		if !graphql.HasFieldError(ctx, fc) {
 9351			ec.Errorf(ctx, "must not be null")
 9352		}
 9353		return graphql.Null
 9354	}
 9355	res := resTmp.(string)
 9356	fc.Result = res
 9357	return ec.marshalNString2string(ctx, field.Selections, res)
 9358}
 9359
 9360func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9361	defer func() {
 9362		if r := recover(); r != nil {
 9363			ec.Error(ctx, ec.Recover(ctx, r))
 9364			ret = graphql.Null
 9365		}
 9366	}()
 9367	fc := &graphql.FieldContext{
 9368		Object:   "__Field",
 9369		Field:    field,
 9370		Args:     nil,
 9371		IsMethod: false,
 9372	}
 9373
 9374	ctx = graphql.WithFieldContext(ctx, fc)
 9375	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9376		ctx = rctx // use context from middleware stack in children
 9377		return obj.Description, nil
 9378	})
 9379	if err != nil {
 9380		ec.Error(ctx, err)
 9381		return graphql.Null
 9382	}
 9383	if resTmp == nil {
 9384		return graphql.Null
 9385	}
 9386	res := resTmp.(string)
 9387	fc.Result = res
 9388	return ec.marshalOString2string(ctx, field.Selections, res)
 9389}
 9390
 9391func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9392	defer func() {
 9393		if r := recover(); r != nil {
 9394			ec.Error(ctx, ec.Recover(ctx, r))
 9395			ret = graphql.Null
 9396		}
 9397	}()
 9398	fc := &graphql.FieldContext{
 9399		Object:   "__Field",
 9400		Field:    field,
 9401		Args:     nil,
 9402		IsMethod: false,
 9403	}
 9404
 9405	ctx = graphql.WithFieldContext(ctx, fc)
 9406	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9407		ctx = rctx // use context from middleware stack in children
 9408		return obj.Args, nil
 9409	})
 9410	if err != nil {
 9411		ec.Error(ctx, err)
 9412		return graphql.Null
 9413	}
 9414	if resTmp == nil {
 9415		if !graphql.HasFieldError(ctx, fc) {
 9416			ec.Errorf(ctx, "must not be null")
 9417		}
 9418		return graphql.Null
 9419	}
 9420	res := resTmp.([]introspection.InputValue)
 9421	fc.Result = res
 9422	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 9423}
 9424
 9425func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9426	defer func() {
 9427		if r := recover(); r != nil {
 9428			ec.Error(ctx, ec.Recover(ctx, r))
 9429			ret = graphql.Null
 9430		}
 9431	}()
 9432	fc := &graphql.FieldContext{
 9433		Object:   "__Field",
 9434		Field:    field,
 9435		Args:     nil,
 9436		IsMethod: false,
 9437	}
 9438
 9439	ctx = graphql.WithFieldContext(ctx, fc)
 9440	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9441		ctx = rctx // use context from middleware stack in children
 9442		return obj.Type, nil
 9443	})
 9444	if err != nil {
 9445		ec.Error(ctx, err)
 9446		return graphql.Null
 9447	}
 9448	if resTmp == nil {
 9449		if !graphql.HasFieldError(ctx, fc) {
 9450			ec.Errorf(ctx, "must not be null")
 9451		}
 9452		return graphql.Null
 9453	}
 9454	res := resTmp.(*introspection.Type)
 9455	fc.Result = res
 9456	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9457}
 9458
 9459func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9460	defer func() {
 9461		if r := recover(); r != nil {
 9462			ec.Error(ctx, ec.Recover(ctx, r))
 9463			ret = graphql.Null
 9464		}
 9465	}()
 9466	fc := &graphql.FieldContext{
 9467		Object:   "__Field",
 9468		Field:    field,
 9469		Args:     nil,
 9470		IsMethod: true,
 9471	}
 9472
 9473	ctx = graphql.WithFieldContext(ctx, fc)
 9474	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9475		ctx = rctx // use context from middleware stack in children
 9476		return obj.IsDeprecated(), nil
 9477	})
 9478	if err != nil {
 9479		ec.Error(ctx, err)
 9480		return graphql.Null
 9481	}
 9482	if resTmp == nil {
 9483		if !graphql.HasFieldError(ctx, fc) {
 9484			ec.Errorf(ctx, "must not be null")
 9485		}
 9486		return graphql.Null
 9487	}
 9488	res := resTmp.(bool)
 9489	fc.Result = res
 9490	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9491}
 9492
 9493func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9494	defer func() {
 9495		if r := recover(); r != nil {
 9496			ec.Error(ctx, ec.Recover(ctx, r))
 9497			ret = graphql.Null
 9498		}
 9499	}()
 9500	fc := &graphql.FieldContext{
 9501		Object:   "__Field",
 9502		Field:    field,
 9503		Args:     nil,
 9504		IsMethod: true,
 9505	}
 9506
 9507	ctx = graphql.WithFieldContext(ctx, fc)
 9508	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9509		ctx = rctx // use context from middleware stack in children
 9510		return obj.DeprecationReason(), nil
 9511	})
 9512	if err != nil {
 9513		ec.Error(ctx, err)
 9514		return graphql.Null
 9515	}
 9516	if resTmp == nil {
 9517		return graphql.Null
 9518	}
 9519	res := resTmp.(*string)
 9520	fc.Result = res
 9521	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9522}
 9523
 9524func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9525	defer func() {
 9526		if r := recover(); r != nil {
 9527			ec.Error(ctx, ec.Recover(ctx, r))
 9528			ret = graphql.Null
 9529		}
 9530	}()
 9531	fc := &graphql.FieldContext{
 9532		Object:   "__InputValue",
 9533		Field:    field,
 9534		Args:     nil,
 9535		IsMethod: false,
 9536	}
 9537
 9538	ctx = graphql.WithFieldContext(ctx, fc)
 9539	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9540		ctx = rctx // use context from middleware stack in children
 9541		return obj.Name, nil
 9542	})
 9543	if err != nil {
 9544		ec.Error(ctx, err)
 9545		return graphql.Null
 9546	}
 9547	if resTmp == nil {
 9548		if !graphql.HasFieldError(ctx, fc) {
 9549			ec.Errorf(ctx, "must not be null")
 9550		}
 9551		return graphql.Null
 9552	}
 9553	res := resTmp.(string)
 9554	fc.Result = res
 9555	return ec.marshalNString2string(ctx, field.Selections, res)
 9556}
 9557
 9558func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9559	defer func() {
 9560		if r := recover(); r != nil {
 9561			ec.Error(ctx, ec.Recover(ctx, r))
 9562			ret = graphql.Null
 9563		}
 9564	}()
 9565	fc := &graphql.FieldContext{
 9566		Object:   "__InputValue",
 9567		Field:    field,
 9568		Args:     nil,
 9569		IsMethod: false,
 9570	}
 9571
 9572	ctx = graphql.WithFieldContext(ctx, fc)
 9573	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9574		ctx = rctx // use context from middleware stack in children
 9575		return obj.Description, nil
 9576	})
 9577	if err != nil {
 9578		ec.Error(ctx, err)
 9579		return graphql.Null
 9580	}
 9581	if resTmp == nil {
 9582		return graphql.Null
 9583	}
 9584	res := resTmp.(string)
 9585	fc.Result = res
 9586	return ec.marshalOString2string(ctx, field.Selections, res)
 9587}
 9588
 9589func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9590	defer func() {
 9591		if r := recover(); r != nil {
 9592			ec.Error(ctx, ec.Recover(ctx, r))
 9593			ret = graphql.Null
 9594		}
 9595	}()
 9596	fc := &graphql.FieldContext{
 9597		Object:   "__InputValue",
 9598		Field:    field,
 9599		Args:     nil,
 9600		IsMethod: false,
 9601	}
 9602
 9603	ctx = graphql.WithFieldContext(ctx, fc)
 9604	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9605		ctx = rctx // use context from middleware stack in children
 9606		return obj.Type, nil
 9607	})
 9608	if err != nil {
 9609		ec.Error(ctx, err)
 9610		return graphql.Null
 9611	}
 9612	if resTmp == nil {
 9613		if !graphql.HasFieldError(ctx, fc) {
 9614			ec.Errorf(ctx, "must not be null")
 9615		}
 9616		return graphql.Null
 9617	}
 9618	res := resTmp.(*introspection.Type)
 9619	fc.Result = res
 9620	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9621}
 9622
 9623func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9624	defer func() {
 9625		if r := recover(); r != nil {
 9626			ec.Error(ctx, ec.Recover(ctx, r))
 9627			ret = graphql.Null
 9628		}
 9629	}()
 9630	fc := &graphql.FieldContext{
 9631		Object:   "__InputValue",
 9632		Field:    field,
 9633		Args:     nil,
 9634		IsMethod: false,
 9635	}
 9636
 9637	ctx = graphql.WithFieldContext(ctx, fc)
 9638	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9639		ctx = rctx // use context from middleware stack in children
 9640		return obj.DefaultValue, nil
 9641	})
 9642	if err != nil {
 9643		ec.Error(ctx, err)
 9644		return graphql.Null
 9645	}
 9646	if resTmp == nil {
 9647		return graphql.Null
 9648	}
 9649	res := resTmp.(*string)
 9650	fc.Result = res
 9651	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9652}
 9653
 9654func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9655	defer func() {
 9656		if r := recover(); r != nil {
 9657			ec.Error(ctx, ec.Recover(ctx, r))
 9658			ret = graphql.Null
 9659		}
 9660	}()
 9661	fc := &graphql.FieldContext{
 9662		Object:   "__Schema",
 9663		Field:    field,
 9664		Args:     nil,
 9665		IsMethod: true,
 9666	}
 9667
 9668	ctx = graphql.WithFieldContext(ctx, fc)
 9669	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9670		ctx = rctx // use context from middleware stack in children
 9671		return obj.Types(), nil
 9672	})
 9673	if err != nil {
 9674		ec.Error(ctx, err)
 9675		return graphql.Null
 9676	}
 9677	if resTmp == nil {
 9678		if !graphql.HasFieldError(ctx, fc) {
 9679			ec.Errorf(ctx, "must not be null")
 9680		}
 9681		return graphql.Null
 9682	}
 9683	res := resTmp.([]introspection.Type)
 9684	fc.Result = res
 9685	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9686}
 9687
 9688func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9689	defer func() {
 9690		if r := recover(); r != nil {
 9691			ec.Error(ctx, ec.Recover(ctx, r))
 9692			ret = graphql.Null
 9693		}
 9694	}()
 9695	fc := &graphql.FieldContext{
 9696		Object:   "__Schema",
 9697		Field:    field,
 9698		Args:     nil,
 9699		IsMethod: true,
 9700	}
 9701
 9702	ctx = graphql.WithFieldContext(ctx, fc)
 9703	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9704		ctx = rctx // use context from middleware stack in children
 9705		return obj.QueryType(), nil
 9706	})
 9707	if err != nil {
 9708		ec.Error(ctx, err)
 9709		return graphql.Null
 9710	}
 9711	if resTmp == nil {
 9712		if !graphql.HasFieldError(ctx, fc) {
 9713			ec.Errorf(ctx, "must not be null")
 9714		}
 9715		return graphql.Null
 9716	}
 9717	res := resTmp.(*introspection.Type)
 9718	fc.Result = res
 9719	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9720}
 9721
 9722func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9723	defer func() {
 9724		if r := recover(); r != nil {
 9725			ec.Error(ctx, ec.Recover(ctx, r))
 9726			ret = graphql.Null
 9727		}
 9728	}()
 9729	fc := &graphql.FieldContext{
 9730		Object:   "__Schema",
 9731		Field:    field,
 9732		Args:     nil,
 9733		IsMethod: true,
 9734	}
 9735
 9736	ctx = graphql.WithFieldContext(ctx, fc)
 9737	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9738		ctx = rctx // use context from middleware stack in children
 9739		return obj.MutationType(), nil
 9740	})
 9741	if err != nil {
 9742		ec.Error(ctx, err)
 9743		return graphql.Null
 9744	}
 9745	if resTmp == nil {
 9746		return graphql.Null
 9747	}
 9748	res := resTmp.(*introspection.Type)
 9749	fc.Result = res
 9750	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9751}
 9752
 9753func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9754	defer func() {
 9755		if r := recover(); r != nil {
 9756			ec.Error(ctx, ec.Recover(ctx, r))
 9757			ret = graphql.Null
 9758		}
 9759	}()
 9760	fc := &graphql.FieldContext{
 9761		Object:   "__Schema",
 9762		Field:    field,
 9763		Args:     nil,
 9764		IsMethod: true,
 9765	}
 9766
 9767	ctx = graphql.WithFieldContext(ctx, fc)
 9768	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9769		ctx = rctx // use context from middleware stack in children
 9770		return obj.SubscriptionType(), nil
 9771	})
 9772	if err != nil {
 9773		ec.Error(ctx, err)
 9774		return graphql.Null
 9775	}
 9776	if resTmp == nil {
 9777		return graphql.Null
 9778	}
 9779	res := resTmp.(*introspection.Type)
 9780	fc.Result = res
 9781	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9782}
 9783
 9784func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9785	defer func() {
 9786		if r := recover(); r != nil {
 9787			ec.Error(ctx, ec.Recover(ctx, r))
 9788			ret = graphql.Null
 9789		}
 9790	}()
 9791	fc := &graphql.FieldContext{
 9792		Object:   "__Schema",
 9793		Field:    field,
 9794		Args:     nil,
 9795		IsMethod: true,
 9796	}
 9797
 9798	ctx = graphql.WithFieldContext(ctx, fc)
 9799	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9800		ctx = rctx // use context from middleware stack in children
 9801		return obj.Directives(), nil
 9802	})
 9803	if err != nil {
 9804		ec.Error(ctx, err)
 9805		return graphql.Null
 9806	}
 9807	if resTmp == nil {
 9808		if !graphql.HasFieldError(ctx, fc) {
 9809			ec.Errorf(ctx, "must not be null")
 9810		}
 9811		return graphql.Null
 9812	}
 9813	res := resTmp.([]introspection.Directive)
 9814	fc.Result = res
 9815	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
 9816}
 9817
 9818func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9819	defer func() {
 9820		if r := recover(); r != nil {
 9821			ec.Error(ctx, ec.Recover(ctx, r))
 9822			ret = graphql.Null
 9823		}
 9824	}()
 9825	fc := &graphql.FieldContext{
 9826		Object:   "__Type",
 9827		Field:    field,
 9828		Args:     nil,
 9829		IsMethod: true,
 9830	}
 9831
 9832	ctx = graphql.WithFieldContext(ctx, fc)
 9833	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9834		ctx = rctx // use context from middleware stack in children
 9835		return obj.Kind(), nil
 9836	})
 9837	if err != nil {
 9838		ec.Error(ctx, err)
 9839		return graphql.Null
 9840	}
 9841	if resTmp == nil {
 9842		if !graphql.HasFieldError(ctx, fc) {
 9843			ec.Errorf(ctx, "must not be null")
 9844		}
 9845		return graphql.Null
 9846	}
 9847	res := resTmp.(string)
 9848	fc.Result = res
 9849	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 9850}
 9851
 9852func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9853	defer func() {
 9854		if r := recover(); r != nil {
 9855			ec.Error(ctx, ec.Recover(ctx, r))
 9856			ret = graphql.Null
 9857		}
 9858	}()
 9859	fc := &graphql.FieldContext{
 9860		Object:   "__Type",
 9861		Field:    field,
 9862		Args:     nil,
 9863		IsMethod: true,
 9864	}
 9865
 9866	ctx = graphql.WithFieldContext(ctx, fc)
 9867	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9868		ctx = rctx // use context from middleware stack in children
 9869		return obj.Name(), nil
 9870	})
 9871	if err != nil {
 9872		ec.Error(ctx, err)
 9873		return graphql.Null
 9874	}
 9875	if resTmp == nil {
 9876		return graphql.Null
 9877	}
 9878	res := resTmp.(*string)
 9879	fc.Result = res
 9880	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9881}
 9882
 9883func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9884	defer func() {
 9885		if r := recover(); r != nil {
 9886			ec.Error(ctx, ec.Recover(ctx, r))
 9887			ret = graphql.Null
 9888		}
 9889	}()
 9890	fc := &graphql.FieldContext{
 9891		Object:   "__Type",
 9892		Field:    field,
 9893		Args:     nil,
 9894		IsMethod: true,
 9895	}
 9896
 9897	ctx = graphql.WithFieldContext(ctx, fc)
 9898	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9899		ctx = rctx // use context from middleware stack in children
 9900		return obj.Description(), nil
 9901	})
 9902	if err != nil {
 9903		ec.Error(ctx, err)
 9904		return graphql.Null
 9905	}
 9906	if resTmp == nil {
 9907		return graphql.Null
 9908	}
 9909	res := resTmp.(string)
 9910	fc.Result = res
 9911	return ec.marshalOString2string(ctx, field.Selections, res)
 9912}
 9913
 9914func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9915	defer func() {
 9916		if r := recover(); r != nil {
 9917			ec.Error(ctx, ec.Recover(ctx, r))
 9918			ret = graphql.Null
 9919		}
 9920	}()
 9921	fc := &graphql.FieldContext{
 9922		Object:   "__Type",
 9923		Field:    field,
 9924		Args:     nil,
 9925		IsMethod: true,
 9926	}
 9927
 9928	ctx = graphql.WithFieldContext(ctx, fc)
 9929	rawArgs := field.ArgumentMap(ec.Variables)
 9930	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 9931	if err != nil {
 9932		ec.Error(ctx, err)
 9933		return graphql.Null
 9934	}
 9935	fc.Args = args
 9936	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9937		ctx = rctx // use context from middleware stack in children
 9938		return obj.Fields(args["includeDeprecated"].(bool)), nil
 9939	})
 9940	if err != nil {
 9941		ec.Error(ctx, err)
 9942		return graphql.Null
 9943	}
 9944	if resTmp == nil {
 9945		return graphql.Null
 9946	}
 9947	res := resTmp.([]introspection.Field)
 9948	fc.Result = res
 9949	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
 9950}
 9951
 9952func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9953	defer func() {
 9954		if r := recover(); r != nil {
 9955			ec.Error(ctx, ec.Recover(ctx, r))
 9956			ret = graphql.Null
 9957		}
 9958	}()
 9959	fc := &graphql.FieldContext{
 9960		Object:   "__Type",
 9961		Field:    field,
 9962		Args:     nil,
 9963		IsMethod: true,
 9964	}
 9965
 9966	ctx = graphql.WithFieldContext(ctx, fc)
 9967	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9968		ctx = rctx // use context from middleware stack in children
 9969		return obj.Interfaces(), nil
 9970	})
 9971	if err != nil {
 9972		ec.Error(ctx, err)
 9973		return graphql.Null
 9974	}
 9975	if resTmp == nil {
 9976		return graphql.Null
 9977	}
 9978	res := resTmp.([]introspection.Type)
 9979	fc.Result = res
 9980	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
 9981}
 9982
 9983func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
 9984	defer func() {
 9985		if r := recover(); r != nil {
 9986			ec.Error(ctx, ec.Recover(ctx, r))
 9987			ret = graphql.Null
 9988		}
 9989	}()
 9990	fc := &graphql.FieldContext{
 9991		Object:   "__Type",
 9992		Field:    field,
 9993		Args:     nil,
 9994		IsMethod: true,
 9995	}
 9996
 9997	ctx = graphql.WithFieldContext(ctx, fc)
 9998	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9999		ctx = rctx // use context from middleware stack in children
10000		return obj.PossibleTypes(), nil
10001	})
10002	if err != nil {
10003		ec.Error(ctx, err)
10004		return graphql.Null
10005	}
10006	if resTmp == nil {
10007		return graphql.Null
10008	}
10009	res := resTmp.([]introspection.Type)
10010	fc.Result = res
10011	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
10012}
10013
10014func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10015	defer func() {
10016		if r := recover(); r != nil {
10017			ec.Error(ctx, ec.Recover(ctx, r))
10018			ret = graphql.Null
10019		}
10020	}()
10021	fc := &graphql.FieldContext{
10022		Object:   "__Type",
10023		Field:    field,
10024		Args:     nil,
10025		IsMethod: true,
10026	}
10027
10028	ctx = graphql.WithFieldContext(ctx, fc)
10029	rawArgs := field.ArgumentMap(ec.Variables)
10030	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10031	if err != nil {
10032		ec.Error(ctx, err)
10033		return graphql.Null
10034	}
10035	fc.Args = args
10036	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10037		ctx = rctx // use context from middleware stack in children
10038		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10039	})
10040	if err != nil {
10041		ec.Error(ctx, err)
10042		return graphql.Null
10043	}
10044	if resTmp == nil {
10045		return graphql.Null
10046	}
10047	res := resTmp.([]introspection.EnumValue)
10048	fc.Result = res
10049	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
10050}
10051
10052func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10053	defer func() {
10054		if r := recover(); r != nil {
10055			ec.Error(ctx, ec.Recover(ctx, r))
10056			ret = graphql.Null
10057		}
10058	}()
10059	fc := &graphql.FieldContext{
10060		Object:   "__Type",
10061		Field:    field,
10062		Args:     nil,
10063		IsMethod: true,
10064	}
10065
10066	ctx = graphql.WithFieldContext(ctx, fc)
10067	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10068		ctx = rctx // use context from middleware stack in children
10069		return obj.InputFields(), nil
10070	})
10071	if err != nil {
10072		ec.Error(ctx, err)
10073		return graphql.Null
10074	}
10075	if resTmp == nil {
10076		return graphql.Null
10077	}
10078	res := resTmp.([]introspection.InputValue)
10079	fc.Result = res
10080	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
10081}
10082
10083func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10084	defer func() {
10085		if r := recover(); r != nil {
10086			ec.Error(ctx, ec.Recover(ctx, r))
10087			ret = graphql.Null
10088		}
10089	}()
10090	fc := &graphql.FieldContext{
10091		Object:   "__Type",
10092		Field:    field,
10093		Args:     nil,
10094		IsMethod: true,
10095	}
10096
10097	ctx = graphql.WithFieldContext(ctx, fc)
10098	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10099		ctx = rctx // use context from middleware stack in children
10100		return obj.OfType(), nil
10101	})
10102	if err != nil {
10103		ec.Error(ctx, err)
10104		return graphql.Null
10105	}
10106	if resTmp == nil {
10107		return graphql.Null
10108	}
10109	res := resTmp.(*introspection.Type)
10110	fc.Result = res
10111	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10112}
10113
10114// endregion **************************** field.gotpl *****************************
10115
10116// region    **************************** input.gotpl *****************************
10117
10118func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10119	var it models.AddCommentInput
10120	var asMap = obj.(map[string]interface{})
10121
10122	for k, v := range asMap {
10123		switch k {
10124		case "clientMutationId":
10125			var err error
10126			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10127			if err != nil {
10128				return it, err
10129			}
10130		case "repoRef":
10131			var err error
10132			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10133			if err != nil {
10134				return it, err
10135			}
10136		case "prefix":
10137			var err error
10138			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10139			if err != nil {
10140				return it, err
10141			}
10142		case "message":
10143			var err error
10144			it.Message, err = ec.unmarshalNString2string(ctx, v)
10145			if err != nil {
10146				return it, err
10147			}
10148		case "files":
10149			var err error
10150			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10151			if err != nil {
10152				return it, err
10153			}
10154		}
10155	}
10156
10157	return it, nil
10158}
10159
10160func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10161	var it models.ChangeLabelInput
10162	var asMap = obj.(map[string]interface{})
10163
10164	for k, v := range asMap {
10165		switch k {
10166		case "clientMutationId":
10167			var err error
10168			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10169			if err != nil {
10170				return it, err
10171			}
10172		case "repoRef":
10173			var err error
10174			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10175			if err != nil {
10176				return it, err
10177			}
10178		case "prefix":
10179			var err error
10180			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10181			if err != nil {
10182				return it, err
10183			}
10184		case "added":
10185			var err error
10186			it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10187			if err != nil {
10188				return it, err
10189			}
10190		case "Removed":
10191			var err error
10192			it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
10193			if err != nil {
10194				return it, err
10195			}
10196		}
10197	}
10198
10199	return it, nil
10200}
10201
10202func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10203	var it models.CloseBugInput
10204	var asMap = obj.(map[string]interface{})
10205
10206	for k, v := range asMap {
10207		switch k {
10208		case "clientMutationId":
10209			var err error
10210			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10211			if err != nil {
10212				return it, err
10213			}
10214		case "repoRef":
10215			var err error
10216			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10217			if err != nil {
10218				return it, err
10219			}
10220		case "prefix":
10221			var err error
10222			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10223			if err != nil {
10224				return it, err
10225			}
10226		}
10227	}
10228
10229	return it, nil
10230}
10231
10232func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10233	var it models.CommitAsNeededInput
10234	var asMap = obj.(map[string]interface{})
10235
10236	for k, v := range asMap {
10237		switch k {
10238		case "clientMutationId":
10239			var err error
10240			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10241			if err != nil {
10242				return it, err
10243			}
10244		case "repoRef":
10245			var err error
10246			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10247			if err != nil {
10248				return it, err
10249			}
10250		case "prefix":
10251			var err error
10252			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10253			if err != nil {
10254				return it, err
10255			}
10256		}
10257	}
10258
10259	return it, nil
10260}
10261
10262func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10263	var it models.CommitInput
10264	var asMap = obj.(map[string]interface{})
10265
10266	for k, v := range asMap {
10267		switch k {
10268		case "clientMutationId":
10269			var err error
10270			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10271			if err != nil {
10272				return it, err
10273			}
10274		case "repoRef":
10275			var err error
10276			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10277			if err != nil {
10278				return it, err
10279			}
10280		case "prefix":
10281			var err error
10282			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10283			if err != nil {
10284				return it, err
10285			}
10286		}
10287	}
10288
10289	return it, nil
10290}
10291
10292func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10293	var it models.NewBugInput
10294	var asMap = obj.(map[string]interface{})
10295
10296	for k, v := range asMap {
10297		switch k {
10298		case "clientMutationId":
10299			var err error
10300			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10301			if err != nil {
10302				return it, err
10303			}
10304		case "repoRef":
10305			var err error
10306			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10307			if err != nil {
10308				return it, err
10309			}
10310		case "title":
10311			var err error
10312			it.Title, err = ec.unmarshalNString2string(ctx, v)
10313			if err != nil {
10314				return it, err
10315			}
10316		case "message":
10317			var err error
10318			it.Message, err = ec.unmarshalNString2string(ctx, v)
10319			if err != nil {
10320				return it, err
10321			}
10322		case "files":
10323			var err error
10324			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx, v)
10325			if err != nil {
10326				return it, err
10327			}
10328		}
10329	}
10330
10331	return it, nil
10332}
10333
10334func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10335	var it models.OpenBugInput
10336	var asMap = obj.(map[string]interface{})
10337
10338	for k, v := range asMap {
10339		switch k {
10340		case "clientMutationId":
10341			var err error
10342			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10343			if err != nil {
10344				return it, err
10345			}
10346		case "repoRef":
10347			var err error
10348			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10349			if err != nil {
10350				return it, err
10351			}
10352		case "prefix":
10353			var err error
10354			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10355			if err != nil {
10356				return it, err
10357			}
10358		}
10359	}
10360
10361	return it, nil
10362}
10363
10364func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10365	var it models.SetTitleInput
10366	var asMap = obj.(map[string]interface{})
10367
10368	for k, v := range asMap {
10369		switch k {
10370		case "clientMutationId":
10371			var err error
10372			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10373			if err != nil {
10374				return it, err
10375			}
10376		case "repoRef":
10377			var err error
10378			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10379			if err != nil {
10380				return it, err
10381			}
10382		case "prefix":
10383			var err error
10384			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10385			if err != nil {
10386				return it, err
10387			}
10388		case "title":
10389			var err error
10390			it.Title, err = ec.unmarshalNString2string(ctx, v)
10391			if err != nil {
10392				return it, err
10393			}
10394		}
10395	}
10396
10397	return it, nil
10398}
10399
10400// endregion **************************** input.gotpl *****************************
10401
10402// region    ************************** interface.gotpl ***************************
10403
10404func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj models.Authored) graphql.Marshaler {
10405	switch obj := (obj).(type) {
10406	case nil:
10407		return graphql.Null
10408	case bug.Comment:
10409		return ec._Comment(ctx, sel, &obj)
10410	case *bug.Comment:
10411		if obj == nil {
10412			return graphql.Null
10413		}
10414		return ec._Comment(ctx, sel, obj)
10415	case models.BugWrapper:
10416		if obj == nil {
10417			return graphql.Null
10418		}
10419		return ec._Bug(ctx, sel, obj)
10420	case *bug.CreateOperation:
10421		if obj == nil {
10422			return graphql.Null
10423		}
10424		return ec._CreateOperation(ctx, sel, obj)
10425	case *bug.SetTitleOperation:
10426		if obj == nil {
10427			return graphql.Null
10428		}
10429		return ec._SetTitleOperation(ctx, sel, obj)
10430	case *bug.AddCommentOperation:
10431		if obj == nil {
10432			return graphql.Null
10433		}
10434		return ec._AddCommentOperation(ctx, sel, obj)
10435	case *bug.EditCommentOperation:
10436		if obj == nil {
10437			return graphql.Null
10438		}
10439		return ec._EditCommentOperation(ctx, sel, obj)
10440	case *bug.SetStatusOperation:
10441		if obj == nil {
10442			return graphql.Null
10443		}
10444		return ec._SetStatusOperation(ctx, sel, obj)
10445	case *bug.LabelChangeOperation:
10446		if obj == nil {
10447			return graphql.Null
10448		}
10449		return ec._LabelChangeOperation(ctx, sel, obj)
10450	case *bug.CreateTimelineItem:
10451		if obj == nil {
10452			return graphql.Null
10453		}
10454		return ec._CreateTimelineItem(ctx, sel, obj)
10455	case *bug.AddCommentTimelineItem:
10456		if obj == nil {
10457			return graphql.Null
10458		}
10459		return ec._AddCommentTimelineItem(ctx, sel, obj)
10460	case *bug.LabelChangeTimelineItem:
10461		if obj == nil {
10462			return graphql.Null
10463		}
10464		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10465	case *bug.SetStatusTimelineItem:
10466		if obj == nil {
10467			return graphql.Null
10468		}
10469		return ec._SetStatusTimelineItem(ctx, sel, obj)
10470	case *bug.SetTitleTimelineItem:
10471		if obj == nil {
10472			return graphql.Null
10473		}
10474		return ec._SetTitleTimelineItem(ctx, sel, obj)
10475	default:
10476		panic(fmt.Errorf("unexpected type %T", obj))
10477	}
10478}
10479
10480func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj bug.Operation) graphql.Marshaler {
10481	switch obj := (obj).(type) {
10482	case nil:
10483		return graphql.Null
10484	case *bug.CreateOperation:
10485		if obj == nil {
10486			return graphql.Null
10487		}
10488		return ec._CreateOperation(ctx, sel, obj)
10489	case *bug.SetTitleOperation:
10490		if obj == nil {
10491			return graphql.Null
10492		}
10493		return ec._SetTitleOperation(ctx, sel, obj)
10494	case *bug.AddCommentOperation:
10495		if obj == nil {
10496			return graphql.Null
10497		}
10498		return ec._AddCommentOperation(ctx, sel, obj)
10499	case *bug.EditCommentOperation:
10500		if obj == nil {
10501			return graphql.Null
10502		}
10503		return ec._EditCommentOperation(ctx, sel, obj)
10504	case *bug.SetStatusOperation:
10505		if obj == nil {
10506			return graphql.Null
10507		}
10508		return ec._SetStatusOperation(ctx, sel, obj)
10509	case *bug.LabelChangeOperation:
10510		if obj == nil {
10511			return graphql.Null
10512		}
10513		return ec._LabelChangeOperation(ctx, sel, obj)
10514	default:
10515		panic(fmt.Errorf("unexpected type %T", obj))
10516	}
10517}
10518
10519func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj bug.TimelineItem) graphql.Marshaler {
10520	switch obj := (obj).(type) {
10521	case nil:
10522		return graphql.Null
10523	case *bug.CreateTimelineItem:
10524		if obj == nil {
10525			return graphql.Null
10526		}
10527		return ec._CreateTimelineItem(ctx, sel, obj)
10528	case *bug.AddCommentTimelineItem:
10529		if obj == nil {
10530			return graphql.Null
10531		}
10532		return ec._AddCommentTimelineItem(ctx, sel, obj)
10533	case bug.LabelChangeTimelineItem:
10534		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10535	case *bug.LabelChangeTimelineItem:
10536		if obj == nil {
10537			return graphql.Null
10538		}
10539		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10540	case bug.SetStatusTimelineItem:
10541		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10542	case *bug.SetStatusTimelineItem:
10543		if obj == nil {
10544			return graphql.Null
10545		}
10546		return ec._SetStatusTimelineItem(ctx, sel, obj)
10547	case bug.SetTitleTimelineItem:
10548		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10549	case *bug.SetTitleTimelineItem:
10550		if obj == nil {
10551			return graphql.Null
10552		}
10553		return ec._SetTitleTimelineItem(ctx, sel, obj)
10554	default:
10555		panic(fmt.Errorf("unexpected type %T", obj))
10556	}
10557}
10558
10559// endregion ************************** interface.gotpl ***************************
10560
10561// region    **************************** object.gotpl ****************************
10562
10563var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10564
10565func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10566	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
10567
10568	out := graphql.NewFieldSet(fields)
10569	var invalids uint32
10570	for i, field := range fields {
10571		switch field.Name {
10572		case "__typename":
10573			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10574		case "id":
10575			field := field
10576			out.Concurrently(i, func() (res graphql.Marshaler) {
10577				defer func() {
10578					if r := recover(); r != nil {
10579						ec.Error(ctx, ec.Recover(ctx, r))
10580					}
10581				}()
10582				res = ec._AddCommentOperation_id(ctx, field, obj)
10583				if res == graphql.Null {
10584					atomic.AddUint32(&invalids, 1)
10585				}
10586				return res
10587			})
10588		case "author":
10589			field := field
10590			out.Concurrently(i, func() (res graphql.Marshaler) {
10591				defer func() {
10592					if r := recover(); r != nil {
10593						ec.Error(ctx, ec.Recover(ctx, r))
10594					}
10595				}()
10596				res = ec._AddCommentOperation_author(ctx, field, obj)
10597				if res == graphql.Null {
10598					atomic.AddUint32(&invalids, 1)
10599				}
10600				return res
10601			})
10602		case "date":
10603			field := field
10604			out.Concurrently(i, func() (res graphql.Marshaler) {
10605				defer func() {
10606					if r := recover(); r != nil {
10607						ec.Error(ctx, ec.Recover(ctx, r))
10608					}
10609				}()
10610				res = ec._AddCommentOperation_date(ctx, field, obj)
10611				if res == graphql.Null {
10612					atomic.AddUint32(&invalids, 1)
10613				}
10614				return res
10615			})
10616		case "message":
10617			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10618			if out.Values[i] == graphql.Null {
10619				atomic.AddUint32(&invalids, 1)
10620			}
10621		case "files":
10622			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10623			if out.Values[i] == graphql.Null {
10624				atomic.AddUint32(&invalids, 1)
10625			}
10626		default:
10627			panic("unknown field " + strconv.Quote(field.Name))
10628		}
10629	}
10630	out.Dispatch()
10631	if invalids > 0 {
10632		return graphql.Null
10633	}
10634	return out
10635}
10636
10637var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10638
10639func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10640	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
10641
10642	out := graphql.NewFieldSet(fields)
10643	var invalids uint32
10644	for i, field := range fields {
10645		switch field.Name {
10646		case "__typename":
10647			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10648		case "clientMutationId":
10649			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10650		case "bug":
10651			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10652			if out.Values[i] == graphql.Null {
10653				invalids++
10654			}
10655		case "operation":
10656			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10657			if out.Values[i] == graphql.Null {
10658				invalids++
10659			}
10660		default:
10661			panic("unknown field " + strconv.Quote(field.Name))
10662		}
10663	}
10664	out.Dispatch()
10665	if invalids > 0 {
10666		return graphql.Null
10667	}
10668	return out
10669}
10670
10671var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10672
10673func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10674	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
10675
10676	out := graphql.NewFieldSet(fields)
10677	var invalids uint32
10678	for i, field := range fields {
10679		switch field.Name {
10680		case "__typename":
10681			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10682		case "id":
10683			field := field
10684			out.Concurrently(i, func() (res graphql.Marshaler) {
10685				defer func() {
10686					if r := recover(); r != nil {
10687						ec.Error(ctx, ec.Recover(ctx, r))
10688					}
10689				}()
10690				res = ec._AddCommentTimelineItem_id(ctx, field, obj)
10691				if res == graphql.Null {
10692					atomic.AddUint32(&invalids, 1)
10693				}
10694				return res
10695			})
10696		case "author":
10697			field := field
10698			out.Concurrently(i, func() (res graphql.Marshaler) {
10699				defer func() {
10700					if r := recover(); r != nil {
10701						ec.Error(ctx, ec.Recover(ctx, r))
10702					}
10703				}()
10704				res = ec._AddCommentTimelineItem_author(ctx, field, obj)
10705				if res == graphql.Null {
10706					atomic.AddUint32(&invalids, 1)
10707				}
10708				return res
10709			})
10710		case "message":
10711			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10712			if out.Values[i] == graphql.Null {
10713				atomic.AddUint32(&invalids, 1)
10714			}
10715		case "messageIsEmpty":
10716			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10717			if out.Values[i] == graphql.Null {
10718				atomic.AddUint32(&invalids, 1)
10719			}
10720		case "files":
10721			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10722			if out.Values[i] == graphql.Null {
10723				atomic.AddUint32(&invalids, 1)
10724			}
10725		case "createdAt":
10726			field := field
10727			out.Concurrently(i, func() (res graphql.Marshaler) {
10728				defer func() {
10729					if r := recover(); r != nil {
10730						ec.Error(ctx, ec.Recover(ctx, r))
10731					}
10732				}()
10733				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10734				if res == graphql.Null {
10735					atomic.AddUint32(&invalids, 1)
10736				}
10737				return res
10738			})
10739		case "lastEdit":
10740			field := field
10741			out.Concurrently(i, func() (res graphql.Marshaler) {
10742				defer func() {
10743					if r := recover(); r != nil {
10744						ec.Error(ctx, ec.Recover(ctx, r))
10745					}
10746				}()
10747				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10748				if res == graphql.Null {
10749					atomic.AddUint32(&invalids, 1)
10750				}
10751				return res
10752			})
10753		case "edited":
10754			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10755			if out.Values[i] == graphql.Null {
10756				atomic.AddUint32(&invalids, 1)
10757			}
10758		case "history":
10759			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10760			if out.Values[i] == graphql.Null {
10761				atomic.AddUint32(&invalids, 1)
10762			}
10763		default:
10764			panic("unknown field " + strconv.Quote(field.Name))
10765		}
10766	}
10767	out.Dispatch()
10768	if invalids > 0 {
10769		return graphql.Null
10770	}
10771	return out
10772}
10773
10774var bugImplementors = []string{"Bug", "Authored"}
10775
10776func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
10777	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
10778
10779	out := graphql.NewFieldSet(fields)
10780	var invalids uint32
10781	for i, field := range fields {
10782		switch field.Name {
10783		case "__typename":
10784			out.Values[i] = graphql.MarshalString("Bug")
10785		case "id":
10786			field := field
10787			out.Concurrently(i, func() (res graphql.Marshaler) {
10788				defer func() {
10789					if r := recover(); r != nil {
10790						ec.Error(ctx, ec.Recover(ctx, r))
10791					}
10792				}()
10793				res = ec._Bug_id(ctx, field, obj)
10794				if res == graphql.Null {
10795					atomic.AddUint32(&invalids, 1)
10796				}
10797				return res
10798			})
10799		case "humanId":
10800			field := field
10801			out.Concurrently(i, func() (res graphql.Marshaler) {
10802				defer func() {
10803					if r := recover(); r != nil {
10804						ec.Error(ctx, ec.Recover(ctx, r))
10805					}
10806				}()
10807				res = ec._Bug_humanId(ctx, field, obj)
10808				if res == graphql.Null {
10809					atomic.AddUint32(&invalids, 1)
10810				}
10811				return res
10812			})
10813		case "status":
10814			field := field
10815			out.Concurrently(i, func() (res graphql.Marshaler) {
10816				defer func() {
10817					if r := recover(); r != nil {
10818						ec.Error(ctx, ec.Recover(ctx, r))
10819					}
10820				}()
10821				res = ec._Bug_status(ctx, field, obj)
10822				if res == graphql.Null {
10823					atomic.AddUint32(&invalids, 1)
10824				}
10825				return res
10826			})
10827		case "title":
10828			out.Values[i] = ec._Bug_title(ctx, field, obj)
10829			if out.Values[i] == graphql.Null {
10830				atomic.AddUint32(&invalids, 1)
10831			}
10832		case "labels":
10833			out.Values[i] = ec._Bug_labels(ctx, field, obj)
10834			if out.Values[i] == graphql.Null {
10835				atomic.AddUint32(&invalids, 1)
10836			}
10837		case "author":
10838			out.Values[i] = ec._Bug_author(ctx, field, obj)
10839			if out.Values[i] == graphql.Null {
10840				atomic.AddUint32(&invalids, 1)
10841			}
10842		case "createdAt":
10843			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
10844			if out.Values[i] == graphql.Null {
10845				atomic.AddUint32(&invalids, 1)
10846			}
10847		case "lastEdit":
10848			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
10849			if out.Values[i] == graphql.Null {
10850				atomic.AddUint32(&invalids, 1)
10851			}
10852		case "actors":
10853			field := field
10854			out.Concurrently(i, func() (res graphql.Marshaler) {
10855				defer func() {
10856					if r := recover(); r != nil {
10857						ec.Error(ctx, ec.Recover(ctx, r))
10858					}
10859				}()
10860				res = ec._Bug_actors(ctx, field, obj)
10861				if res == graphql.Null {
10862					atomic.AddUint32(&invalids, 1)
10863				}
10864				return res
10865			})
10866		case "participants":
10867			field := field
10868			out.Concurrently(i, func() (res graphql.Marshaler) {
10869				defer func() {
10870					if r := recover(); r != nil {
10871						ec.Error(ctx, ec.Recover(ctx, r))
10872					}
10873				}()
10874				res = ec._Bug_participants(ctx, field, obj)
10875				if res == graphql.Null {
10876					atomic.AddUint32(&invalids, 1)
10877				}
10878				return res
10879			})
10880		case "comments":
10881			field := field
10882			out.Concurrently(i, func() (res graphql.Marshaler) {
10883				defer func() {
10884					if r := recover(); r != nil {
10885						ec.Error(ctx, ec.Recover(ctx, r))
10886					}
10887				}()
10888				res = ec._Bug_comments(ctx, field, obj)
10889				if res == graphql.Null {
10890					atomic.AddUint32(&invalids, 1)
10891				}
10892				return res
10893			})
10894		case "timeline":
10895			field := field
10896			out.Concurrently(i, func() (res graphql.Marshaler) {
10897				defer func() {
10898					if r := recover(); r != nil {
10899						ec.Error(ctx, ec.Recover(ctx, r))
10900					}
10901				}()
10902				res = ec._Bug_timeline(ctx, field, obj)
10903				if res == graphql.Null {
10904					atomic.AddUint32(&invalids, 1)
10905				}
10906				return res
10907			})
10908		case "operations":
10909			field := field
10910			out.Concurrently(i, func() (res graphql.Marshaler) {
10911				defer func() {
10912					if r := recover(); r != nil {
10913						ec.Error(ctx, ec.Recover(ctx, r))
10914					}
10915				}()
10916				res = ec._Bug_operations(ctx, field, obj)
10917				if res == graphql.Null {
10918					atomic.AddUint32(&invalids, 1)
10919				}
10920				return res
10921			})
10922		default:
10923			panic("unknown field " + strconv.Quote(field.Name))
10924		}
10925	}
10926	out.Dispatch()
10927	if invalids > 0 {
10928		return graphql.Null
10929	}
10930	return out
10931}
10932
10933var bugConnectionImplementors = []string{"BugConnection"}
10934
10935func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
10936	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
10937
10938	out := graphql.NewFieldSet(fields)
10939	var invalids uint32
10940	for i, field := range fields {
10941		switch field.Name {
10942		case "__typename":
10943			out.Values[i] = graphql.MarshalString("BugConnection")
10944		case "edges":
10945			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
10946			if out.Values[i] == graphql.Null {
10947				invalids++
10948			}
10949		case "nodes":
10950			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
10951			if out.Values[i] == graphql.Null {
10952				invalids++
10953			}
10954		case "pageInfo":
10955			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
10956			if out.Values[i] == graphql.Null {
10957				invalids++
10958			}
10959		case "totalCount":
10960			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
10961			if out.Values[i] == graphql.Null {
10962				invalids++
10963			}
10964		default:
10965			panic("unknown field " + strconv.Quote(field.Name))
10966		}
10967	}
10968	out.Dispatch()
10969	if invalids > 0 {
10970		return graphql.Null
10971	}
10972	return out
10973}
10974
10975var bugEdgeImplementors = []string{"BugEdge"}
10976
10977func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
10978	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
10979
10980	out := graphql.NewFieldSet(fields)
10981	var invalids uint32
10982	for i, field := range fields {
10983		switch field.Name {
10984		case "__typename":
10985			out.Values[i] = graphql.MarshalString("BugEdge")
10986		case "cursor":
10987			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
10988			if out.Values[i] == graphql.Null {
10989				invalids++
10990			}
10991		case "node":
10992			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
10993			if out.Values[i] == graphql.Null {
10994				invalids++
10995			}
10996		default:
10997			panic("unknown field " + strconv.Quote(field.Name))
10998		}
10999	}
11000	out.Dispatch()
11001	if invalids > 0 {
11002		return graphql.Null
11003	}
11004	return out
11005}
11006
11007var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11008
11009func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11010	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
11011
11012	out := graphql.NewFieldSet(fields)
11013	var invalids uint32
11014	for i, field := range fields {
11015		switch field.Name {
11016		case "__typename":
11017			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11018		case "clientMutationId":
11019			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11020		case "bug":
11021			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11022			if out.Values[i] == graphql.Null {
11023				invalids++
11024			}
11025		case "operation":
11026			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11027			if out.Values[i] == graphql.Null {
11028				invalids++
11029			}
11030		case "results":
11031			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11032			if out.Values[i] == graphql.Null {
11033				invalids++
11034			}
11035		default:
11036			panic("unknown field " + strconv.Quote(field.Name))
11037		}
11038	}
11039	out.Dispatch()
11040	if invalids > 0 {
11041		return graphql.Null
11042	}
11043	return out
11044}
11045
11046var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11047
11048func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11049	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
11050
11051	out := graphql.NewFieldSet(fields)
11052	var invalids uint32
11053	for i, field := range fields {
11054		switch field.Name {
11055		case "__typename":
11056			out.Values[i] = graphql.MarshalString("CloseBugPayload")
11057		case "clientMutationId":
11058			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11059		case "bug":
11060			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11061			if out.Values[i] == graphql.Null {
11062				invalids++
11063			}
11064		case "operation":
11065			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11066			if out.Values[i] == graphql.Null {
11067				invalids++
11068			}
11069		default:
11070			panic("unknown field " + strconv.Quote(field.Name))
11071		}
11072	}
11073	out.Dispatch()
11074	if invalids > 0 {
11075		return graphql.Null
11076	}
11077	return out
11078}
11079
11080var colorImplementors = []string{"Color"}
11081
11082func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11083	fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
11084
11085	out := graphql.NewFieldSet(fields)
11086	var invalids uint32
11087	for i, field := range fields {
11088		switch field.Name {
11089		case "__typename":
11090			out.Values[i] = graphql.MarshalString("Color")
11091		case "R":
11092			field := field
11093			out.Concurrently(i, func() (res graphql.Marshaler) {
11094				defer func() {
11095					if r := recover(); r != nil {
11096						ec.Error(ctx, ec.Recover(ctx, r))
11097					}
11098				}()
11099				res = ec._Color_R(ctx, field, obj)
11100				if res == graphql.Null {
11101					atomic.AddUint32(&invalids, 1)
11102				}
11103				return res
11104			})
11105		case "G":
11106			field := field
11107			out.Concurrently(i, func() (res graphql.Marshaler) {
11108				defer func() {
11109					if r := recover(); r != nil {
11110						ec.Error(ctx, ec.Recover(ctx, r))
11111					}
11112				}()
11113				res = ec._Color_G(ctx, field, obj)
11114				if res == graphql.Null {
11115					atomic.AddUint32(&invalids, 1)
11116				}
11117				return res
11118			})
11119		case "B":
11120			field := field
11121			out.Concurrently(i, func() (res graphql.Marshaler) {
11122				defer func() {
11123					if r := recover(); r != nil {
11124						ec.Error(ctx, ec.Recover(ctx, r))
11125					}
11126				}()
11127				res = ec._Color_B(ctx, field, obj)
11128				if res == graphql.Null {
11129					atomic.AddUint32(&invalids, 1)
11130				}
11131				return res
11132			})
11133		default:
11134			panic("unknown field " + strconv.Quote(field.Name))
11135		}
11136	}
11137	out.Dispatch()
11138	if invalids > 0 {
11139		return graphql.Null
11140	}
11141	return out
11142}
11143
11144var commentImplementors = []string{"Comment", "Authored"}
11145
11146func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11147	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
11148
11149	out := graphql.NewFieldSet(fields)
11150	var invalids uint32
11151	for i, field := range fields {
11152		switch field.Name {
11153		case "__typename":
11154			out.Values[i] = graphql.MarshalString("Comment")
11155		case "author":
11156			field := field
11157			out.Concurrently(i, func() (res graphql.Marshaler) {
11158				defer func() {
11159					if r := recover(); r != nil {
11160						ec.Error(ctx, ec.Recover(ctx, r))
11161					}
11162				}()
11163				res = ec._Comment_author(ctx, field, obj)
11164				if res == graphql.Null {
11165					atomic.AddUint32(&invalids, 1)
11166				}
11167				return res
11168			})
11169		case "message":
11170			out.Values[i] = ec._Comment_message(ctx, field, obj)
11171			if out.Values[i] == graphql.Null {
11172				atomic.AddUint32(&invalids, 1)
11173			}
11174		case "files":
11175			out.Values[i] = ec._Comment_files(ctx, field, obj)
11176			if out.Values[i] == graphql.Null {
11177				atomic.AddUint32(&invalids, 1)
11178			}
11179		default:
11180			panic("unknown field " + strconv.Quote(field.Name))
11181		}
11182	}
11183	out.Dispatch()
11184	if invalids > 0 {
11185		return graphql.Null
11186	}
11187	return out
11188}
11189
11190var commentConnectionImplementors = []string{"CommentConnection"}
11191
11192func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11193	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
11194
11195	out := graphql.NewFieldSet(fields)
11196	var invalids uint32
11197	for i, field := range fields {
11198		switch field.Name {
11199		case "__typename":
11200			out.Values[i] = graphql.MarshalString("CommentConnection")
11201		case "edges":
11202			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11203			if out.Values[i] == graphql.Null {
11204				invalids++
11205			}
11206		case "nodes":
11207			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11208			if out.Values[i] == graphql.Null {
11209				invalids++
11210			}
11211		case "pageInfo":
11212			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11213			if out.Values[i] == graphql.Null {
11214				invalids++
11215			}
11216		case "totalCount":
11217			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11218			if out.Values[i] == graphql.Null {
11219				invalids++
11220			}
11221		default:
11222			panic("unknown field " + strconv.Quote(field.Name))
11223		}
11224	}
11225	out.Dispatch()
11226	if invalids > 0 {
11227		return graphql.Null
11228	}
11229	return out
11230}
11231
11232var commentEdgeImplementors = []string{"CommentEdge"}
11233
11234func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11235	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
11236
11237	out := graphql.NewFieldSet(fields)
11238	var invalids uint32
11239	for i, field := range fields {
11240		switch field.Name {
11241		case "__typename":
11242			out.Values[i] = graphql.MarshalString("CommentEdge")
11243		case "cursor":
11244			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11245			if out.Values[i] == graphql.Null {
11246				invalids++
11247			}
11248		case "node":
11249			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11250			if out.Values[i] == graphql.Null {
11251				invalids++
11252			}
11253		default:
11254			panic("unknown field " + strconv.Quote(field.Name))
11255		}
11256	}
11257	out.Dispatch()
11258	if invalids > 0 {
11259		return graphql.Null
11260	}
11261	return out
11262}
11263
11264var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11265
11266func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11267	fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
11268
11269	out := graphql.NewFieldSet(fields)
11270	var invalids uint32
11271	for i, field := range fields {
11272		switch field.Name {
11273		case "__typename":
11274			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11275		case "message":
11276			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11277			if out.Values[i] == graphql.Null {
11278				atomic.AddUint32(&invalids, 1)
11279			}
11280		case "date":
11281			field := field
11282			out.Concurrently(i, func() (res graphql.Marshaler) {
11283				defer func() {
11284					if r := recover(); r != nil {
11285						ec.Error(ctx, ec.Recover(ctx, r))
11286					}
11287				}()
11288				res = ec._CommentHistoryStep_date(ctx, field, obj)
11289				if res == graphql.Null {
11290					atomic.AddUint32(&invalids, 1)
11291				}
11292				return res
11293			})
11294		default:
11295			panic("unknown field " + strconv.Quote(field.Name))
11296		}
11297	}
11298	out.Dispatch()
11299	if invalids > 0 {
11300		return graphql.Null
11301	}
11302	return out
11303}
11304
11305var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11306
11307func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11308	fields := graphql.CollectFields(ec.OperationContext, sel, commitAsNeededPayloadImplementors)
11309
11310	out := graphql.NewFieldSet(fields)
11311	var invalids uint32
11312	for i, field := range fields {
11313		switch field.Name {
11314		case "__typename":
11315			out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11316		case "clientMutationId":
11317			out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11318		case "bug":
11319			out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11320			if out.Values[i] == graphql.Null {
11321				invalids++
11322			}
11323		default:
11324			panic("unknown field " + strconv.Quote(field.Name))
11325		}
11326	}
11327	out.Dispatch()
11328	if invalids > 0 {
11329		return graphql.Null
11330	}
11331	return out
11332}
11333
11334var commitPayloadImplementors = []string{"CommitPayload"}
11335
11336func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11337	fields := graphql.CollectFields(ec.OperationContext, sel, commitPayloadImplementors)
11338
11339	out := graphql.NewFieldSet(fields)
11340	var invalids uint32
11341	for i, field := range fields {
11342		switch field.Name {
11343		case "__typename":
11344			out.Values[i] = graphql.MarshalString("CommitPayload")
11345		case "clientMutationId":
11346			out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11347		case "bug":
11348			out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11349			if out.Values[i] == graphql.Null {
11350				invalids++
11351			}
11352		default:
11353			panic("unknown field " + strconv.Quote(field.Name))
11354		}
11355	}
11356	out.Dispatch()
11357	if invalids > 0 {
11358		return graphql.Null
11359	}
11360	return out
11361}
11362
11363var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11364
11365func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11366	fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
11367
11368	out := graphql.NewFieldSet(fields)
11369	var invalids uint32
11370	for i, field := range fields {
11371		switch field.Name {
11372		case "__typename":
11373			out.Values[i] = graphql.MarshalString("CreateOperation")
11374		case "id":
11375			field := field
11376			out.Concurrently(i, func() (res graphql.Marshaler) {
11377				defer func() {
11378					if r := recover(); r != nil {
11379						ec.Error(ctx, ec.Recover(ctx, r))
11380					}
11381				}()
11382				res = ec._CreateOperation_id(ctx, field, obj)
11383				if res == graphql.Null {
11384					atomic.AddUint32(&invalids, 1)
11385				}
11386				return res
11387			})
11388		case "author":
11389			field := field
11390			out.Concurrently(i, func() (res graphql.Marshaler) {
11391				defer func() {
11392					if r := recover(); r != nil {
11393						ec.Error(ctx, ec.Recover(ctx, r))
11394					}
11395				}()
11396				res = ec._CreateOperation_author(ctx, field, obj)
11397				if res == graphql.Null {
11398					atomic.AddUint32(&invalids, 1)
11399				}
11400				return res
11401			})
11402		case "date":
11403			field := field
11404			out.Concurrently(i, func() (res graphql.Marshaler) {
11405				defer func() {
11406					if r := recover(); r != nil {
11407						ec.Error(ctx, ec.Recover(ctx, r))
11408					}
11409				}()
11410				res = ec._CreateOperation_date(ctx, field, obj)
11411				if res == graphql.Null {
11412					atomic.AddUint32(&invalids, 1)
11413				}
11414				return res
11415			})
11416		case "title":
11417			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11418			if out.Values[i] == graphql.Null {
11419				atomic.AddUint32(&invalids, 1)
11420			}
11421		case "message":
11422			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11423			if out.Values[i] == graphql.Null {
11424				atomic.AddUint32(&invalids, 1)
11425			}
11426		case "files":
11427			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11428			if out.Values[i] == graphql.Null {
11429				atomic.AddUint32(&invalids, 1)
11430			}
11431		default:
11432			panic("unknown field " + strconv.Quote(field.Name))
11433		}
11434	}
11435	out.Dispatch()
11436	if invalids > 0 {
11437		return graphql.Null
11438	}
11439	return out
11440}
11441
11442var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11443
11444func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11445	fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
11446
11447	out := graphql.NewFieldSet(fields)
11448	var invalids uint32
11449	for i, field := range fields {
11450		switch field.Name {
11451		case "__typename":
11452			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11453		case "id":
11454			field := field
11455			out.Concurrently(i, func() (res graphql.Marshaler) {
11456				defer func() {
11457					if r := recover(); r != nil {
11458						ec.Error(ctx, ec.Recover(ctx, r))
11459					}
11460				}()
11461				res = ec._CreateTimelineItem_id(ctx, field, obj)
11462				if res == graphql.Null {
11463					atomic.AddUint32(&invalids, 1)
11464				}
11465				return res
11466			})
11467		case "author":
11468			field := field
11469			out.Concurrently(i, func() (res graphql.Marshaler) {
11470				defer func() {
11471					if r := recover(); r != nil {
11472						ec.Error(ctx, ec.Recover(ctx, r))
11473					}
11474				}()
11475				res = ec._CreateTimelineItem_author(ctx, field, obj)
11476				if res == graphql.Null {
11477					atomic.AddUint32(&invalids, 1)
11478				}
11479				return res
11480			})
11481		case "message":
11482			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11483			if out.Values[i] == graphql.Null {
11484				atomic.AddUint32(&invalids, 1)
11485			}
11486		case "messageIsEmpty":
11487			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11488			if out.Values[i] == graphql.Null {
11489				atomic.AddUint32(&invalids, 1)
11490			}
11491		case "files":
11492			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11493			if out.Values[i] == graphql.Null {
11494				atomic.AddUint32(&invalids, 1)
11495			}
11496		case "createdAt":
11497			field := field
11498			out.Concurrently(i, func() (res graphql.Marshaler) {
11499				defer func() {
11500					if r := recover(); r != nil {
11501						ec.Error(ctx, ec.Recover(ctx, r))
11502					}
11503				}()
11504				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11505				if res == graphql.Null {
11506					atomic.AddUint32(&invalids, 1)
11507				}
11508				return res
11509			})
11510		case "lastEdit":
11511			field := field
11512			out.Concurrently(i, func() (res graphql.Marshaler) {
11513				defer func() {
11514					if r := recover(); r != nil {
11515						ec.Error(ctx, ec.Recover(ctx, r))
11516					}
11517				}()
11518				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11519				if res == graphql.Null {
11520					atomic.AddUint32(&invalids, 1)
11521				}
11522				return res
11523			})
11524		case "edited":
11525			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11526			if out.Values[i] == graphql.Null {
11527				atomic.AddUint32(&invalids, 1)
11528			}
11529		case "history":
11530			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11531			if out.Values[i] == graphql.Null {
11532				atomic.AddUint32(&invalids, 1)
11533			}
11534		default:
11535			panic("unknown field " + strconv.Quote(field.Name))
11536		}
11537	}
11538	out.Dispatch()
11539	if invalids > 0 {
11540		return graphql.Null
11541	}
11542	return out
11543}
11544
11545var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11546
11547func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11548	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
11549
11550	out := graphql.NewFieldSet(fields)
11551	var invalids uint32
11552	for i, field := range fields {
11553		switch field.Name {
11554		case "__typename":
11555			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11556		case "id":
11557			field := field
11558			out.Concurrently(i, func() (res graphql.Marshaler) {
11559				defer func() {
11560					if r := recover(); r != nil {
11561						ec.Error(ctx, ec.Recover(ctx, r))
11562					}
11563				}()
11564				res = ec._EditCommentOperation_id(ctx, field, obj)
11565				if res == graphql.Null {
11566					atomic.AddUint32(&invalids, 1)
11567				}
11568				return res
11569			})
11570		case "author":
11571			field := field
11572			out.Concurrently(i, func() (res graphql.Marshaler) {
11573				defer func() {
11574					if r := recover(); r != nil {
11575						ec.Error(ctx, ec.Recover(ctx, r))
11576					}
11577				}()
11578				res = ec._EditCommentOperation_author(ctx, field, obj)
11579				if res == graphql.Null {
11580					atomic.AddUint32(&invalids, 1)
11581				}
11582				return res
11583			})
11584		case "date":
11585			field := field
11586			out.Concurrently(i, func() (res graphql.Marshaler) {
11587				defer func() {
11588					if r := recover(); r != nil {
11589						ec.Error(ctx, ec.Recover(ctx, r))
11590					}
11591				}()
11592				res = ec._EditCommentOperation_date(ctx, field, obj)
11593				if res == graphql.Null {
11594					atomic.AddUint32(&invalids, 1)
11595				}
11596				return res
11597			})
11598		case "target":
11599			field := field
11600			out.Concurrently(i, func() (res graphql.Marshaler) {
11601				defer func() {
11602					if r := recover(); r != nil {
11603						ec.Error(ctx, ec.Recover(ctx, r))
11604					}
11605				}()
11606				res = ec._EditCommentOperation_target(ctx, field, obj)
11607				if res == graphql.Null {
11608					atomic.AddUint32(&invalids, 1)
11609				}
11610				return res
11611			})
11612		case "message":
11613			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11614			if out.Values[i] == graphql.Null {
11615				atomic.AddUint32(&invalids, 1)
11616			}
11617		case "files":
11618			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11619			if out.Values[i] == graphql.Null {
11620				atomic.AddUint32(&invalids, 1)
11621			}
11622		default:
11623			panic("unknown field " + strconv.Quote(field.Name))
11624		}
11625	}
11626	out.Dispatch()
11627	if invalids > 0 {
11628		return graphql.Null
11629	}
11630	return out
11631}
11632
11633var identityImplementors = []string{"Identity"}
11634
11635func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
11636	fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
11637
11638	out := graphql.NewFieldSet(fields)
11639	var invalids uint32
11640	for i, field := range fields {
11641		switch field.Name {
11642		case "__typename":
11643			out.Values[i] = graphql.MarshalString("Identity")
11644		case "id":
11645			field := field
11646			out.Concurrently(i, func() (res graphql.Marshaler) {
11647				defer func() {
11648					if r := recover(); r != nil {
11649						ec.Error(ctx, ec.Recover(ctx, r))
11650					}
11651				}()
11652				res = ec._Identity_id(ctx, field, obj)
11653				if res == graphql.Null {
11654					atomic.AddUint32(&invalids, 1)
11655				}
11656				return res
11657			})
11658		case "humanId":
11659			field := field
11660			out.Concurrently(i, func() (res graphql.Marshaler) {
11661				defer func() {
11662					if r := recover(); r != nil {
11663						ec.Error(ctx, ec.Recover(ctx, r))
11664					}
11665				}()
11666				res = ec._Identity_humanId(ctx, field, obj)
11667				if res == graphql.Null {
11668					atomic.AddUint32(&invalids, 1)
11669				}
11670				return res
11671			})
11672		case "name":
11673			out.Values[i] = ec._Identity_name(ctx, field, obj)
11674		case "email":
11675			out.Values[i] = ec._Identity_email(ctx, field, obj)
11676		case "displayName":
11677			out.Values[i] = ec._Identity_displayName(ctx, field, obj)
11678			if out.Values[i] == graphql.Null {
11679				atomic.AddUint32(&invalids, 1)
11680			}
11681		case "avatarUrl":
11682			out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
11683		case "isProtected":
11684			out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
11685			if out.Values[i] == graphql.Null {
11686				atomic.AddUint32(&invalids, 1)
11687			}
11688		default:
11689			panic("unknown field " + strconv.Quote(field.Name))
11690		}
11691	}
11692	out.Dispatch()
11693	if invalids > 0 {
11694		return graphql.Null
11695	}
11696	return out
11697}
11698
11699var identityConnectionImplementors = []string{"IdentityConnection"}
11700
11701func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11702	fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
11703
11704	out := graphql.NewFieldSet(fields)
11705	var invalids uint32
11706	for i, field := range fields {
11707		switch field.Name {
11708		case "__typename":
11709			out.Values[i] = graphql.MarshalString("IdentityConnection")
11710		case "edges":
11711			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11712			if out.Values[i] == graphql.Null {
11713				invalids++
11714			}
11715		case "nodes":
11716			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11717			if out.Values[i] == graphql.Null {
11718				invalids++
11719			}
11720		case "pageInfo":
11721			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11722			if out.Values[i] == graphql.Null {
11723				invalids++
11724			}
11725		case "totalCount":
11726			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11727			if out.Values[i] == graphql.Null {
11728				invalids++
11729			}
11730		default:
11731			panic("unknown field " + strconv.Quote(field.Name))
11732		}
11733	}
11734	out.Dispatch()
11735	if invalids > 0 {
11736		return graphql.Null
11737	}
11738	return out
11739}
11740
11741var identityEdgeImplementors = []string{"IdentityEdge"}
11742
11743func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11744	fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
11745
11746	out := graphql.NewFieldSet(fields)
11747	var invalids uint32
11748	for i, field := range fields {
11749		switch field.Name {
11750		case "__typename":
11751			out.Values[i] = graphql.MarshalString("IdentityEdge")
11752		case "cursor":
11753			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11754			if out.Values[i] == graphql.Null {
11755				invalids++
11756			}
11757		case "node":
11758			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11759			if out.Values[i] == graphql.Null {
11760				invalids++
11761			}
11762		default:
11763			panic("unknown field " + strconv.Quote(field.Name))
11764		}
11765	}
11766	out.Dispatch()
11767	if invalids > 0 {
11768		return graphql.Null
11769	}
11770	return out
11771}
11772
11773var labelImplementors = []string{"Label"}
11774
11775func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11776	fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
11777
11778	out := graphql.NewFieldSet(fields)
11779	var invalids uint32
11780	for i, field := range fields {
11781		switch field.Name {
11782		case "__typename":
11783			out.Values[i] = graphql.MarshalString("Label")
11784		case "name":
11785			field := field
11786			out.Concurrently(i, func() (res graphql.Marshaler) {
11787				defer func() {
11788					if r := recover(); r != nil {
11789						ec.Error(ctx, ec.Recover(ctx, r))
11790					}
11791				}()
11792				res = ec._Label_name(ctx, field, obj)
11793				if res == graphql.Null {
11794					atomic.AddUint32(&invalids, 1)
11795				}
11796				return res
11797			})
11798		case "color":
11799			field := field
11800			out.Concurrently(i, func() (res graphql.Marshaler) {
11801				defer func() {
11802					if r := recover(); r != nil {
11803						ec.Error(ctx, ec.Recover(ctx, r))
11804					}
11805				}()
11806				res = ec._Label_color(ctx, field, obj)
11807				if res == graphql.Null {
11808					atomic.AddUint32(&invalids, 1)
11809				}
11810				return res
11811			})
11812		default:
11813			panic("unknown field " + strconv.Quote(field.Name))
11814		}
11815	}
11816	out.Dispatch()
11817	if invalids > 0 {
11818		return graphql.Null
11819	}
11820	return out
11821}
11822
11823var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
11824
11825func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
11826	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
11827
11828	out := graphql.NewFieldSet(fields)
11829	var invalids uint32
11830	for i, field := range fields {
11831		switch field.Name {
11832		case "__typename":
11833			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
11834		case "id":
11835			field := field
11836			out.Concurrently(i, func() (res graphql.Marshaler) {
11837				defer func() {
11838					if r := recover(); r != nil {
11839						ec.Error(ctx, ec.Recover(ctx, r))
11840					}
11841				}()
11842				res = ec._LabelChangeOperation_id(ctx, field, obj)
11843				if res == graphql.Null {
11844					atomic.AddUint32(&invalids, 1)
11845				}
11846				return res
11847			})
11848		case "author":
11849			field := field
11850			out.Concurrently(i, func() (res graphql.Marshaler) {
11851				defer func() {
11852					if r := recover(); r != nil {
11853						ec.Error(ctx, ec.Recover(ctx, r))
11854					}
11855				}()
11856				res = ec._LabelChangeOperation_author(ctx, field, obj)
11857				if res == graphql.Null {
11858					atomic.AddUint32(&invalids, 1)
11859				}
11860				return res
11861			})
11862		case "date":
11863			field := field
11864			out.Concurrently(i, func() (res graphql.Marshaler) {
11865				defer func() {
11866					if r := recover(); r != nil {
11867						ec.Error(ctx, ec.Recover(ctx, r))
11868					}
11869				}()
11870				res = ec._LabelChangeOperation_date(ctx, field, obj)
11871				if res == graphql.Null {
11872					atomic.AddUint32(&invalids, 1)
11873				}
11874				return res
11875			})
11876		case "added":
11877			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
11878			if out.Values[i] == graphql.Null {
11879				atomic.AddUint32(&invalids, 1)
11880			}
11881		case "removed":
11882			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
11883			if out.Values[i] == graphql.Null {
11884				atomic.AddUint32(&invalids, 1)
11885			}
11886		default:
11887			panic("unknown field " + strconv.Quote(field.Name))
11888		}
11889	}
11890	out.Dispatch()
11891	if invalids > 0 {
11892		return graphql.Null
11893	}
11894	return out
11895}
11896
11897var labelChangeResultImplementors = []string{"LabelChangeResult"}
11898
11899func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
11900	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
11901
11902	out := graphql.NewFieldSet(fields)
11903	var invalids uint32
11904	for i, field := range fields {
11905		switch field.Name {
11906		case "__typename":
11907			out.Values[i] = graphql.MarshalString("LabelChangeResult")
11908		case "label":
11909			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
11910			if out.Values[i] == graphql.Null {
11911				atomic.AddUint32(&invalids, 1)
11912			}
11913		case "status":
11914			field := field
11915			out.Concurrently(i, func() (res graphql.Marshaler) {
11916				defer func() {
11917					if r := recover(); r != nil {
11918						ec.Error(ctx, ec.Recover(ctx, r))
11919					}
11920				}()
11921				res = ec._LabelChangeResult_status(ctx, field, obj)
11922				if res == graphql.Null {
11923					atomic.AddUint32(&invalids, 1)
11924				}
11925				return res
11926			})
11927		default:
11928			panic("unknown field " + strconv.Quote(field.Name))
11929		}
11930	}
11931	out.Dispatch()
11932	if invalids > 0 {
11933		return graphql.Null
11934	}
11935	return out
11936}
11937
11938var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
11939
11940func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
11941	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
11942
11943	out := graphql.NewFieldSet(fields)
11944	var invalids uint32
11945	for i, field := range fields {
11946		switch field.Name {
11947		case "__typename":
11948			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
11949		case "id":
11950			field := field
11951			out.Concurrently(i, func() (res graphql.Marshaler) {
11952				defer func() {
11953					if r := recover(); r != nil {
11954						ec.Error(ctx, ec.Recover(ctx, r))
11955					}
11956				}()
11957				res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
11958				if res == graphql.Null {
11959					atomic.AddUint32(&invalids, 1)
11960				}
11961				return res
11962			})
11963		case "author":
11964			field := field
11965			out.Concurrently(i, func() (res graphql.Marshaler) {
11966				defer func() {
11967					if r := recover(); r != nil {
11968						ec.Error(ctx, ec.Recover(ctx, r))
11969					}
11970				}()
11971				res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
11972				if res == graphql.Null {
11973					atomic.AddUint32(&invalids, 1)
11974				}
11975				return res
11976			})
11977		case "date":
11978			field := field
11979			out.Concurrently(i, func() (res graphql.Marshaler) {
11980				defer func() {
11981					if r := recover(); r != nil {
11982						ec.Error(ctx, ec.Recover(ctx, r))
11983					}
11984				}()
11985				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
11986				if res == graphql.Null {
11987					atomic.AddUint32(&invalids, 1)
11988				}
11989				return res
11990			})
11991		case "added":
11992			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
11993			if out.Values[i] == graphql.Null {
11994				atomic.AddUint32(&invalids, 1)
11995			}
11996		case "removed":
11997			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
11998			if out.Values[i] == graphql.Null {
11999				atomic.AddUint32(&invalids, 1)
12000			}
12001		default:
12002			panic("unknown field " + strconv.Quote(field.Name))
12003		}
12004	}
12005	out.Dispatch()
12006	if invalids > 0 {
12007		return graphql.Null
12008	}
12009	return out
12010}
12011
12012var labelConnectionImplementors = []string{"LabelConnection"}
12013
12014func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
12015	fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
12016
12017	out := graphql.NewFieldSet(fields)
12018	var invalids uint32
12019	for i, field := range fields {
12020		switch field.Name {
12021		case "__typename":
12022			out.Values[i] = graphql.MarshalString("LabelConnection")
12023		case "edges":
12024			out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
12025			if out.Values[i] == graphql.Null {
12026				invalids++
12027			}
12028		case "nodes":
12029			out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
12030			if out.Values[i] == graphql.Null {
12031				invalids++
12032			}
12033		case "pageInfo":
12034			out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
12035			if out.Values[i] == graphql.Null {
12036				invalids++
12037			}
12038		case "totalCount":
12039			out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
12040			if out.Values[i] == graphql.Null {
12041				invalids++
12042			}
12043		default:
12044			panic("unknown field " + strconv.Quote(field.Name))
12045		}
12046	}
12047	out.Dispatch()
12048	if invalids > 0 {
12049		return graphql.Null
12050	}
12051	return out
12052}
12053
12054var labelEdgeImplementors = []string{"LabelEdge"}
12055
12056func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
12057	fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
12058
12059	out := graphql.NewFieldSet(fields)
12060	var invalids uint32
12061	for i, field := range fields {
12062		switch field.Name {
12063		case "__typename":
12064			out.Values[i] = graphql.MarshalString("LabelEdge")
12065		case "cursor":
12066			out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
12067			if out.Values[i] == graphql.Null {
12068				invalids++
12069			}
12070		case "node":
12071			out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
12072			if out.Values[i] == graphql.Null {
12073				invalids++
12074			}
12075		default:
12076			panic("unknown field " + strconv.Quote(field.Name))
12077		}
12078	}
12079	out.Dispatch()
12080	if invalids > 0 {
12081		return graphql.Null
12082	}
12083	return out
12084}
12085
12086var mutationImplementors = []string{"Mutation"}
12087
12088func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12089	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
12090
12091	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12092		Object: "Mutation",
12093	})
12094
12095	out := graphql.NewFieldSet(fields)
12096	var invalids uint32
12097	for i, field := range fields {
12098		switch field.Name {
12099		case "__typename":
12100			out.Values[i] = graphql.MarshalString("Mutation")
12101		case "newBug":
12102			out.Values[i] = ec._Mutation_newBug(ctx, field)
12103			if out.Values[i] == graphql.Null {
12104				invalids++
12105			}
12106		case "addComment":
12107			out.Values[i] = ec._Mutation_addComment(ctx, field)
12108			if out.Values[i] == graphql.Null {
12109				invalids++
12110			}
12111		case "changeLabels":
12112			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12113			if out.Values[i] == graphql.Null {
12114				invalids++
12115			}
12116		case "openBug":
12117			out.Values[i] = ec._Mutation_openBug(ctx, field)
12118			if out.Values[i] == graphql.Null {
12119				invalids++
12120			}
12121		case "closeBug":
12122			out.Values[i] = ec._Mutation_closeBug(ctx, field)
12123			if out.Values[i] == graphql.Null {
12124				invalids++
12125			}
12126		case "setTitle":
12127			out.Values[i] = ec._Mutation_setTitle(ctx, field)
12128			if out.Values[i] == graphql.Null {
12129				invalids++
12130			}
12131		case "commit":
12132			out.Values[i] = ec._Mutation_commit(ctx, field)
12133			if out.Values[i] == graphql.Null {
12134				invalids++
12135			}
12136		case "commitAsNeeded":
12137			out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12138			if out.Values[i] == graphql.Null {
12139				invalids++
12140			}
12141		default:
12142			panic("unknown field " + strconv.Quote(field.Name))
12143		}
12144	}
12145	out.Dispatch()
12146	if invalids > 0 {
12147		return graphql.Null
12148	}
12149	return out
12150}
12151
12152var newBugPayloadImplementors = []string{"NewBugPayload"}
12153
12154func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12155	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
12156
12157	out := graphql.NewFieldSet(fields)
12158	var invalids uint32
12159	for i, field := range fields {
12160		switch field.Name {
12161		case "__typename":
12162			out.Values[i] = graphql.MarshalString("NewBugPayload")
12163		case "clientMutationId":
12164			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12165		case "bug":
12166			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12167			if out.Values[i] == graphql.Null {
12168				invalids++
12169			}
12170		case "operation":
12171			out.Values[i] = ec._NewBugPayload_operation(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 openBugPayloadImplementors = []string{"OpenBugPayload"}
12187
12188func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12189	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
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("OpenBugPayload")
12197		case "clientMutationId":
12198			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12199		case "bug":
12200			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12201			if out.Values[i] == graphql.Null {
12202				invalids++
12203			}
12204		case "operation":
12205			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12206			if out.Values[i] == graphql.Null {
12207				invalids++
12208			}
12209		default:
12210			panic("unknown field " + strconv.Quote(field.Name))
12211		}
12212	}
12213	out.Dispatch()
12214	if invalids > 0 {
12215		return graphql.Null
12216	}
12217	return out
12218}
12219
12220var operationConnectionImplementors = []string{"OperationConnection"}
12221
12222func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12223	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
12224
12225	out := graphql.NewFieldSet(fields)
12226	var invalids uint32
12227	for i, field := range fields {
12228		switch field.Name {
12229		case "__typename":
12230			out.Values[i] = graphql.MarshalString("OperationConnection")
12231		case "edges":
12232			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12233			if out.Values[i] == graphql.Null {
12234				invalids++
12235			}
12236		case "nodes":
12237			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12238			if out.Values[i] == graphql.Null {
12239				invalids++
12240			}
12241		case "pageInfo":
12242			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12243			if out.Values[i] == graphql.Null {
12244				invalids++
12245			}
12246		case "totalCount":
12247			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12248			if out.Values[i] == graphql.Null {
12249				invalids++
12250			}
12251		default:
12252			panic("unknown field " + strconv.Quote(field.Name))
12253		}
12254	}
12255	out.Dispatch()
12256	if invalids > 0 {
12257		return graphql.Null
12258	}
12259	return out
12260}
12261
12262var operationEdgeImplementors = []string{"OperationEdge"}
12263
12264func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12265	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
12266
12267	out := graphql.NewFieldSet(fields)
12268	var invalids uint32
12269	for i, field := range fields {
12270		switch field.Name {
12271		case "__typename":
12272			out.Values[i] = graphql.MarshalString("OperationEdge")
12273		case "cursor":
12274			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12275			if out.Values[i] == graphql.Null {
12276				invalids++
12277			}
12278		case "node":
12279			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12280			if out.Values[i] == graphql.Null {
12281				invalids++
12282			}
12283		default:
12284			panic("unknown field " + strconv.Quote(field.Name))
12285		}
12286	}
12287	out.Dispatch()
12288	if invalids > 0 {
12289		return graphql.Null
12290	}
12291	return out
12292}
12293
12294var pageInfoImplementors = []string{"PageInfo"}
12295
12296func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12297	fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
12298
12299	out := graphql.NewFieldSet(fields)
12300	var invalids uint32
12301	for i, field := range fields {
12302		switch field.Name {
12303		case "__typename":
12304			out.Values[i] = graphql.MarshalString("PageInfo")
12305		case "hasNextPage":
12306			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12307			if out.Values[i] == graphql.Null {
12308				invalids++
12309			}
12310		case "hasPreviousPage":
12311			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12312			if out.Values[i] == graphql.Null {
12313				invalids++
12314			}
12315		case "startCursor":
12316			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12317			if out.Values[i] == graphql.Null {
12318				invalids++
12319			}
12320		case "endCursor":
12321			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12322			if out.Values[i] == graphql.Null {
12323				invalids++
12324			}
12325		default:
12326			panic("unknown field " + strconv.Quote(field.Name))
12327		}
12328	}
12329	out.Dispatch()
12330	if invalids > 0 {
12331		return graphql.Null
12332	}
12333	return out
12334}
12335
12336var queryImplementors = []string{"Query"}
12337
12338func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12339	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
12340
12341	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
12342		Object: "Query",
12343	})
12344
12345	out := graphql.NewFieldSet(fields)
12346	var invalids uint32
12347	for i, field := range fields {
12348		switch field.Name {
12349		case "__typename":
12350			out.Values[i] = graphql.MarshalString("Query")
12351		case "repository":
12352			field := field
12353			out.Concurrently(i, func() (res graphql.Marshaler) {
12354				defer func() {
12355					if r := recover(); r != nil {
12356						ec.Error(ctx, ec.Recover(ctx, r))
12357					}
12358				}()
12359				res = ec._Query_repository(ctx, field)
12360				return res
12361			})
12362		case "__type":
12363			out.Values[i] = ec._Query___type(ctx, field)
12364		case "__schema":
12365			out.Values[i] = ec._Query___schema(ctx, field)
12366		default:
12367			panic("unknown field " + strconv.Quote(field.Name))
12368		}
12369	}
12370	out.Dispatch()
12371	if invalids > 0 {
12372		return graphql.Null
12373	}
12374	return out
12375}
12376
12377var repositoryImplementors = []string{"Repository"}
12378
12379func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12380	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
12381
12382	out := graphql.NewFieldSet(fields)
12383	var invalids uint32
12384	for i, field := range fields {
12385		switch field.Name {
12386		case "__typename":
12387			out.Values[i] = graphql.MarshalString("Repository")
12388		case "allBugs":
12389			field := field
12390			out.Concurrently(i, func() (res graphql.Marshaler) {
12391				defer func() {
12392					if r := recover(); r != nil {
12393						ec.Error(ctx, ec.Recover(ctx, r))
12394					}
12395				}()
12396				res = ec._Repository_allBugs(ctx, field, obj)
12397				if res == graphql.Null {
12398					atomic.AddUint32(&invalids, 1)
12399				}
12400				return res
12401			})
12402		case "bug":
12403			field := field
12404			out.Concurrently(i, func() (res graphql.Marshaler) {
12405				defer func() {
12406					if r := recover(); r != nil {
12407						ec.Error(ctx, ec.Recover(ctx, r))
12408					}
12409				}()
12410				res = ec._Repository_bug(ctx, field, obj)
12411				return res
12412			})
12413		case "allIdentities":
12414			field := field
12415			out.Concurrently(i, func() (res graphql.Marshaler) {
12416				defer func() {
12417					if r := recover(); r != nil {
12418						ec.Error(ctx, ec.Recover(ctx, r))
12419					}
12420				}()
12421				res = ec._Repository_allIdentities(ctx, field, obj)
12422				if res == graphql.Null {
12423					atomic.AddUint32(&invalids, 1)
12424				}
12425				return res
12426			})
12427		case "identity":
12428			field := field
12429			out.Concurrently(i, func() (res graphql.Marshaler) {
12430				defer func() {
12431					if r := recover(); r != nil {
12432						ec.Error(ctx, ec.Recover(ctx, r))
12433					}
12434				}()
12435				res = ec._Repository_identity(ctx, field, obj)
12436				return res
12437			})
12438		case "userIdentity":
12439			field := field
12440			out.Concurrently(i, func() (res graphql.Marshaler) {
12441				defer func() {
12442					if r := recover(); r != nil {
12443						ec.Error(ctx, ec.Recover(ctx, r))
12444					}
12445				}()
12446				res = ec._Repository_userIdentity(ctx, field, obj)
12447				return res
12448			})
12449		case "validLabels":
12450			field := field
12451			out.Concurrently(i, func() (res graphql.Marshaler) {
12452				defer func() {
12453					if r := recover(); r != nil {
12454						ec.Error(ctx, ec.Recover(ctx, r))
12455					}
12456				}()
12457				res = ec._Repository_validLabels(ctx, field, obj)
12458				if res == graphql.Null {
12459					atomic.AddUint32(&invalids, 1)
12460				}
12461				return res
12462			})
12463		default:
12464			panic("unknown field " + strconv.Quote(field.Name))
12465		}
12466	}
12467	out.Dispatch()
12468	if invalids > 0 {
12469		return graphql.Null
12470	}
12471	return out
12472}
12473
12474var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12475
12476func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12477	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
12478
12479	out := graphql.NewFieldSet(fields)
12480	var invalids uint32
12481	for i, field := range fields {
12482		switch field.Name {
12483		case "__typename":
12484			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12485		case "id":
12486			field := field
12487			out.Concurrently(i, func() (res graphql.Marshaler) {
12488				defer func() {
12489					if r := recover(); r != nil {
12490						ec.Error(ctx, ec.Recover(ctx, r))
12491					}
12492				}()
12493				res = ec._SetStatusOperation_id(ctx, field, obj)
12494				if res == graphql.Null {
12495					atomic.AddUint32(&invalids, 1)
12496				}
12497				return res
12498			})
12499		case "author":
12500			field := field
12501			out.Concurrently(i, func() (res graphql.Marshaler) {
12502				defer func() {
12503					if r := recover(); r != nil {
12504						ec.Error(ctx, ec.Recover(ctx, r))
12505					}
12506				}()
12507				res = ec._SetStatusOperation_author(ctx, field, obj)
12508				if res == graphql.Null {
12509					atomic.AddUint32(&invalids, 1)
12510				}
12511				return res
12512			})
12513		case "date":
12514			field := field
12515			out.Concurrently(i, func() (res graphql.Marshaler) {
12516				defer func() {
12517					if r := recover(); r != nil {
12518						ec.Error(ctx, ec.Recover(ctx, r))
12519					}
12520				}()
12521				res = ec._SetStatusOperation_date(ctx, field, obj)
12522				if res == graphql.Null {
12523					atomic.AddUint32(&invalids, 1)
12524				}
12525				return res
12526			})
12527		case "status":
12528			field := field
12529			out.Concurrently(i, func() (res graphql.Marshaler) {
12530				defer func() {
12531					if r := recover(); r != nil {
12532						ec.Error(ctx, ec.Recover(ctx, r))
12533					}
12534				}()
12535				res = ec._SetStatusOperation_status(ctx, field, obj)
12536				if res == graphql.Null {
12537					atomic.AddUint32(&invalids, 1)
12538				}
12539				return res
12540			})
12541		default:
12542			panic("unknown field " + strconv.Quote(field.Name))
12543		}
12544	}
12545	out.Dispatch()
12546	if invalids > 0 {
12547		return graphql.Null
12548	}
12549	return out
12550}
12551
12552var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12553
12554func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12555	fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
12556
12557	out := graphql.NewFieldSet(fields)
12558	var invalids uint32
12559	for i, field := range fields {
12560		switch field.Name {
12561		case "__typename":
12562			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12563		case "id":
12564			field := field
12565			out.Concurrently(i, func() (res graphql.Marshaler) {
12566				defer func() {
12567					if r := recover(); r != nil {
12568						ec.Error(ctx, ec.Recover(ctx, r))
12569					}
12570				}()
12571				res = ec._SetStatusTimelineItem_id(ctx, field, obj)
12572				if res == graphql.Null {
12573					atomic.AddUint32(&invalids, 1)
12574				}
12575				return res
12576			})
12577		case "author":
12578			field := field
12579			out.Concurrently(i, func() (res graphql.Marshaler) {
12580				defer func() {
12581					if r := recover(); r != nil {
12582						ec.Error(ctx, ec.Recover(ctx, r))
12583					}
12584				}()
12585				res = ec._SetStatusTimelineItem_author(ctx, field, obj)
12586				if res == graphql.Null {
12587					atomic.AddUint32(&invalids, 1)
12588				}
12589				return res
12590			})
12591		case "date":
12592			field := field
12593			out.Concurrently(i, func() (res graphql.Marshaler) {
12594				defer func() {
12595					if r := recover(); r != nil {
12596						ec.Error(ctx, ec.Recover(ctx, r))
12597					}
12598				}()
12599				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12600				if res == graphql.Null {
12601					atomic.AddUint32(&invalids, 1)
12602				}
12603				return res
12604			})
12605		case "status":
12606			field := field
12607			out.Concurrently(i, func() (res graphql.Marshaler) {
12608				defer func() {
12609					if r := recover(); r != nil {
12610						ec.Error(ctx, ec.Recover(ctx, r))
12611					}
12612				}()
12613				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12614				if res == graphql.Null {
12615					atomic.AddUint32(&invalids, 1)
12616				}
12617				return res
12618			})
12619		default:
12620			panic("unknown field " + strconv.Quote(field.Name))
12621		}
12622	}
12623	out.Dispatch()
12624	if invalids > 0 {
12625		return graphql.Null
12626	}
12627	return out
12628}
12629
12630var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12631
12632func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12633	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
12634
12635	out := graphql.NewFieldSet(fields)
12636	var invalids uint32
12637	for i, field := range fields {
12638		switch field.Name {
12639		case "__typename":
12640			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12641		case "id":
12642			field := field
12643			out.Concurrently(i, func() (res graphql.Marshaler) {
12644				defer func() {
12645					if r := recover(); r != nil {
12646						ec.Error(ctx, ec.Recover(ctx, r))
12647					}
12648				}()
12649				res = ec._SetTitleOperation_id(ctx, field, obj)
12650				if res == graphql.Null {
12651					atomic.AddUint32(&invalids, 1)
12652				}
12653				return res
12654			})
12655		case "author":
12656			field := field
12657			out.Concurrently(i, func() (res graphql.Marshaler) {
12658				defer func() {
12659					if r := recover(); r != nil {
12660						ec.Error(ctx, ec.Recover(ctx, r))
12661					}
12662				}()
12663				res = ec._SetTitleOperation_author(ctx, field, obj)
12664				if res == graphql.Null {
12665					atomic.AddUint32(&invalids, 1)
12666				}
12667				return res
12668			})
12669		case "date":
12670			field := field
12671			out.Concurrently(i, func() (res graphql.Marshaler) {
12672				defer func() {
12673					if r := recover(); r != nil {
12674						ec.Error(ctx, ec.Recover(ctx, r))
12675					}
12676				}()
12677				res = ec._SetTitleOperation_date(ctx, field, obj)
12678				if res == graphql.Null {
12679					atomic.AddUint32(&invalids, 1)
12680				}
12681				return res
12682			})
12683		case "title":
12684			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12685			if out.Values[i] == graphql.Null {
12686				atomic.AddUint32(&invalids, 1)
12687			}
12688		case "was":
12689			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12690			if out.Values[i] == graphql.Null {
12691				atomic.AddUint32(&invalids, 1)
12692			}
12693		default:
12694			panic("unknown field " + strconv.Quote(field.Name))
12695		}
12696	}
12697	out.Dispatch()
12698	if invalids > 0 {
12699		return graphql.Null
12700	}
12701	return out
12702}
12703
12704var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12705
12706func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12707	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
12708
12709	out := graphql.NewFieldSet(fields)
12710	var invalids uint32
12711	for i, field := range fields {
12712		switch field.Name {
12713		case "__typename":
12714			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12715		case "clientMutationId":
12716			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12717		case "bug":
12718			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12719			if out.Values[i] == graphql.Null {
12720				invalids++
12721			}
12722		case "operation":
12723			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12724			if out.Values[i] == graphql.Null {
12725				invalids++
12726			}
12727		default:
12728			panic("unknown field " + strconv.Quote(field.Name))
12729		}
12730	}
12731	out.Dispatch()
12732	if invalids > 0 {
12733		return graphql.Null
12734	}
12735	return out
12736}
12737
12738var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12739
12740func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12741	fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
12742
12743	out := graphql.NewFieldSet(fields)
12744	var invalids uint32
12745	for i, field := range fields {
12746		switch field.Name {
12747		case "__typename":
12748			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12749		case "id":
12750			field := field
12751			out.Concurrently(i, func() (res graphql.Marshaler) {
12752				defer func() {
12753					if r := recover(); r != nil {
12754						ec.Error(ctx, ec.Recover(ctx, r))
12755					}
12756				}()
12757				res = ec._SetTitleTimelineItem_id(ctx, field, obj)
12758				if res == graphql.Null {
12759					atomic.AddUint32(&invalids, 1)
12760				}
12761				return res
12762			})
12763		case "author":
12764			field := field
12765			out.Concurrently(i, func() (res graphql.Marshaler) {
12766				defer func() {
12767					if r := recover(); r != nil {
12768						ec.Error(ctx, ec.Recover(ctx, r))
12769					}
12770				}()
12771				res = ec._SetTitleTimelineItem_author(ctx, field, obj)
12772				if res == graphql.Null {
12773					atomic.AddUint32(&invalids, 1)
12774				}
12775				return res
12776			})
12777		case "date":
12778			field := field
12779			out.Concurrently(i, func() (res graphql.Marshaler) {
12780				defer func() {
12781					if r := recover(); r != nil {
12782						ec.Error(ctx, ec.Recover(ctx, r))
12783					}
12784				}()
12785				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12786				if res == graphql.Null {
12787					atomic.AddUint32(&invalids, 1)
12788				}
12789				return res
12790			})
12791		case "title":
12792			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12793			if out.Values[i] == graphql.Null {
12794				atomic.AddUint32(&invalids, 1)
12795			}
12796		case "was":
12797			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12798			if out.Values[i] == graphql.Null {
12799				atomic.AddUint32(&invalids, 1)
12800			}
12801		default:
12802			panic("unknown field " + strconv.Quote(field.Name))
12803		}
12804	}
12805	out.Dispatch()
12806	if invalids > 0 {
12807		return graphql.Null
12808	}
12809	return out
12810}
12811
12812var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12813
12814func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12815	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
12816
12817	out := graphql.NewFieldSet(fields)
12818	var invalids uint32
12819	for i, field := range fields {
12820		switch field.Name {
12821		case "__typename":
12822			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12823		case "edges":
12824			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12825			if out.Values[i] == graphql.Null {
12826				invalids++
12827			}
12828		case "nodes":
12829			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12830			if out.Values[i] == graphql.Null {
12831				invalids++
12832			}
12833		case "pageInfo":
12834			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12835			if out.Values[i] == graphql.Null {
12836				invalids++
12837			}
12838		case "totalCount":
12839			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12840			if out.Values[i] == graphql.Null {
12841				invalids++
12842			}
12843		default:
12844			panic("unknown field " + strconv.Quote(field.Name))
12845		}
12846	}
12847	out.Dispatch()
12848	if invalids > 0 {
12849		return graphql.Null
12850	}
12851	return out
12852}
12853
12854var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12855
12856func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12857	fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
12858
12859	out := graphql.NewFieldSet(fields)
12860	var invalids uint32
12861	for i, field := range fields {
12862		switch field.Name {
12863		case "__typename":
12864			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12865		case "cursor":
12866			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12867			if out.Values[i] == graphql.Null {
12868				invalids++
12869			}
12870		case "node":
12871			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12872			if out.Values[i] == graphql.Null {
12873				invalids++
12874			}
12875		default:
12876			panic("unknown field " + strconv.Quote(field.Name))
12877		}
12878	}
12879	out.Dispatch()
12880	if invalids > 0 {
12881		return graphql.Null
12882	}
12883	return out
12884}
12885
12886var __DirectiveImplementors = []string{"__Directive"}
12887
12888func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12889	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
12890
12891	out := graphql.NewFieldSet(fields)
12892	var invalids uint32
12893	for i, field := range fields {
12894		switch field.Name {
12895		case "__typename":
12896			out.Values[i] = graphql.MarshalString("__Directive")
12897		case "name":
12898			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12899			if out.Values[i] == graphql.Null {
12900				invalids++
12901			}
12902		case "description":
12903			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12904		case "locations":
12905			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12906			if out.Values[i] == graphql.Null {
12907				invalids++
12908			}
12909		case "args":
12910			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12911			if out.Values[i] == graphql.Null {
12912				invalids++
12913			}
12914		default:
12915			panic("unknown field " + strconv.Quote(field.Name))
12916		}
12917	}
12918	out.Dispatch()
12919	if invalids > 0 {
12920		return graphql.Null
12921	}
12922	return out
12923}
12924
12925var __EnumValueImplementors = []string{"__EnumValue"}
12926
12927func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12928	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
12929
12930	out := graphql.NewFieldSet(fields)
12931	var invalids uint32
12932	for i, field := range fields {
12933		switch field.Name {
12934		case "__typename":
12935			out.Values[i] = graphql.MarshalString("__EnumValue")
12936		case "name":
12937			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12938			if out.Values[i] == graphql.Null {
12939				invalids++
12940			}
12941		case "description":
12942			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12943		case "isDeprecated":
12944			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12945			if out.Values[i] == graphql.Null {
12946				invalids++
12947			}
12948		case "deprecationReason":
12949			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12950		default:
12951			panic("unknown field " + strconv.Quote(field.Name))
12952		}
12953	}
12954	out.Dispatch()
12955	if invalids > 0 {
12956		return graphql.Null
12957	}
12958	return out
12959}
12960
12961var __FieldImplementors = []string{"__Field"}
12962
12963func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12964	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
12965
12966	out := graphql.NewFieldSet(fields)
12967	var invalids uint32
12968	for i, field := range fields {
12969		switch field.Name {
12970		case "__typename":
12971			out.Values[i] = graphql.MarshalString("__Field")
12972		case "name":
12973			out.Values[i] = ec.___Field_name(ctx, field, obj)
12974			if out.Values[i] == graphql.Null {
12975				invalids++
12976			}
12977		case "description":
12978			out.Values[i] = ec.___Field_description(ctx, field, obj)
12979		case "args":
12980			out.Values[i] = ec.___Field_args(ctx, field, obj)
12981			if out.Values[i] == graphql.Null {
12982				invalids++
12983			}
12984		case "type":
12985			out.Values[i] = ec.___Field_type(ctx, field, obj)
12986			if out.Values[i] == graphql.Null {
12987				invalids++
12988			}
12989		case "isDeprecated":
12990			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
12991			if out.Values[i] == graphql.Null {
12992				invalids++
12993			}
12994		case "deprecationReason":
12995			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
12996		default:
12997			panic("unknown field " + strconv.Quote(field.Name))
12998		}
12999	}
13000	out.Dispatch()
13001	if invalids > 0 {
13002		return graphql.Null
13003	}
13004	return out
13005}
13006
13007var __InputValueImplementors = []string{"__InputValue"}
13008
13009func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13010	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
13011
13012	out := graphql.NewFieldSet(fields)
13013	var invalids uint32
13014	for i, field := range fields {
13015		switch field.Name {
13016		case "__typename":
13017			out.Values[i] = graphql.MarshalString("__InputValue")
13018		case "name":
13019			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13020			if out.Values[i] == graphql.Null {
13021				invalids++
13022			}
13023		case "description":
13024			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13025		case "type":
13026			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13027			if out.Values[i] == graphql.Null {
13028				invalids++
13029			}
13030		case "defaultValue":
13031			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13032		default:
13033			panic("unknown field " + strconv.Quote(field.Name))
13034		}
13035	}
13036	out.Dispatch()
13037	if invalids > 0 {
13038		return graphql.Null
13039	}
13040	return out
13041}
13042
13043var __SchemaImplementors = []string{"__Schema"}
13044
13045func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13046	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
13047
13048	out := graphql.NewFieldSet(fields)
13049	var invalids uint32
13050	for i, field := range fields {
13051		switch field.Name {
13052		case "__typename":
13053			out.Values[i] = graphql.MarshalString("__Schema")
13054		case "types":
13055			out.Values[i] = ec.___Schema_types(ctx, field, obj)
13056			if out.Values[i] == graphql.Null {
13057				invalids++
13058			}
13059		case "queryType":
13060			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13061			if out.Values[i] == graphql.Null {
13062				invalids++
13063			}
13064		case "mutationType":
13065			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13066		case "subscriptionType":
13067			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13068		case "directives":
13069			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13070			if out.Values[i] == graphql.Null {
13071				invalids++
13072			}
13073		default:
13074			panic("unknown field " + strconv.Quote(field.Name))
13075		}
13076	}
13077	out.Dispatch()
13078	if invalids > 0 {
13079		return graphql.Null
13080	}
13081	return out
13082}
13083
13084var __TypeImplementors = []string{"__Type"}
13085
13086func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13087	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
13088
13089	out := graphql.NewFieldSet(fields)
13090	var invalids uint32
13091	for i, field := range fields {
13092		switch field.Name {
13093		case "__typename":
13094			out.Values[i] = graphql.MarshalString("__Type")
13095		case "kind":
13096			out.Values[i] = ec.___Type_kind(ctx, field, obj)
13097			if out.Values[i] == graphql.Null {
13098				invalids++
13099			}
13100		case "name":
13101			out.Values[i] = ec.___Type_name(ctx, field, obj)
13102		case "description":
13103			out.Values[i] = ec.___Type_description(ctx, field, obj)
13104		case "fields":
13105			out.Values[i] = ec.___Type_fields(ctx, field, obj)
13106		case "interfaces":
13107			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13108		case "possibleTypes":
13109			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13110		case "enumValues":
13111			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13112		case "inputFields":
13113			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13114		case "ofType":
13115			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13116		default:
13117			panic("unknown field " + strconv.Quote(field.Name))
13118		}
13119	}
13120	out.Dispatch()
13121	if invalids > 0 {
13122		return graphql.Null
13123	}
13124	return out
13125}
13126
13127// endregion **************************** object.gotpl ****************************
13128
13129// region    ***************************** type.gotpl *****************************
13130
13131func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13132	return ec.unmarshalInputAddCommentInput(ctx, v)
13133}
13134
13135func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13136	return ec._AddCommentOperation(ctx, sel, &v)
13137}
13138
13139func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13140	if v == nil {
13141		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13142			ec.Errorf(ctx, "must not be null")
13143		}
13144		return graphql.Null
13145	}
13146	return ec._AddCommentOperation(ctx, sel, v)
13147}
13148
13149func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13150	return ec._AddCommentPayload(ctx, sel, &v)
13151}
13152
13153func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13154	if v == nil {
13155		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13156			ec.Errorf(ctx, "must not be null")
13157		}
13158		return graphql.Null
13159	}
13160	return ec._AddCommentPayload(ctx, sel, v)
13161}
13162
13163func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13164	return graphql.UnmarshalBoolean(v)
13165}
13166
13167func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13168	res := graphql.MarshalBoolean(v)
13169	if res == graphql.Null {
13170		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13171			ec.Errorf(ctx, "must not be null")
13172		}
13173	}
13174	return res
13175}
13176
13177func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
13178	if v == nil {
13179		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13180			ec.Errorf(ctx, "must not be null")
13181		}
13182		return graphql.Null
13183	}
13184	return ec._Bug(ctx, sel, v)
13185}
13186
13187func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
13188	ret := make(graphql.Array, len(v))
13189	var wg sync.WaitGroup
13190	isLen1 := len(v) == 1
13191	if !isLen1 {
13192		wg.Add(len(v))
13193	}
13194	for i := range v {
13195		i := i
13196		fc := &graphql.FieldContext{
13197			Index:  &i,
13198			Result: &v[i],
13199		}
13200		ctx := graphql.WithFieldContext(ctx, fc)
13201		f := func(i int) {
13202			defer func() {
13203				if r := recover(); r != nil {
13204					ec.Error(ctx, ec.Recover(ctx, r))
13205					ret = nil
13206				}
13207			}()
13208			if !isLen1 {
13209				defer wg.Done()
13210			}
13211			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
13212		}
13213		if isLen1 {
13214			f(i)
13215		} else {
13216			go f(i)
13217		}
13218
13219	}
13220	wg.Wait()
13221	return ret
13222}
13223
13224func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13225	return ec._BugConnection(ctx, sel, &v)
13226}
13227
13228func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) 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._BugConnection(ctx, sel, v)
13236}
13237
13238func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13239	return ec._BugEdge(ctx, sel, &v)
13240}
13241
13242func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13243	ret := make(graphql.Array, len(v))
13244	var wg sync.WaitGroup
13245	isLen1 := len(v) == 1
13246	if !isLen1 {
13247		wg.Add(len(v))
13248	}
13249	for i := range v {
13250		i := i
13251		fc := &graphql.FieldContext{
13252			Index:  &i,
13253			Result: &v[i],
13254		}
13255		ctx := graphql.WithFieldContext(ctx, fc)
13256		f := func(i int) {
13257			defer func() {
13258				if r := recover(); r != nil {
13259					ec.Error(ctx, ec.Recover(ctx, r))
13260					ret = nil
13261				}
13262			}()
13263			if !isLen1 {
13264				defer wg.Done()
13265			}
13266			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13267		}
13268		if isLen1 {
13269			f(i)
13270		} else {
13271			go f(i)
13272		}
13273
13274	}
13275	wg.Wait()
13276	return ret
13277}
13278
13279func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13280	if v == nil {
13281		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13282			ec.Errorf(ctx, "must not be null")
13283		}
13284		return graphql.Null
13285	}
13286	return ec._BugEdge(ctx, sel, v)
13287}
13288
13289func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13290	return ec._ChangeLabelPayload(ctx, sel, &v)
13291}
13292
13293func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13294	if v == nil {
13295		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13296			ec.Errorf(ctx, "must not be null")
13297		}
13298		return graphql.Null
13299	}
13300	return ec._ChangeLabelPayload(ctx, sel, v)
13301}
13302
13303func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13304	return ec.unmarshalInputCloseBugInput(ctx, v)
13305}
13306
13307func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13308	return ec._CloseBugPayload(ctx, sel, &v)
13309}
13310
13311func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) 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._CloseBugPayload(ctx, sel, v)
13319}
13320
13321func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13322	return ec._Color(ctx, sel, &v)
13323}
13324
13325func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) 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._Color(ctx, sel, v)
13333}
13334
13335func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13336	return ec._Comment(ctx, sel, &v)
13337}
13338
13339func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) 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.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(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) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) 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._Comment(ctx, sel, v)
13384}
13385
13386func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13387	return ec._CommentConnection(ctx, sel, &v)
13388}
13389
13390func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13391	if v == nil {
13392		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13393			ec.Errorf(ctx, "must not be null")
13394		}
13395		return graphql.Null
13396	}
13397	return ec._CommentConnection(ctx, sel, v)
13398}
13399
13400func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13401	return ec._CommentEdge(ctx, sel, &v)
13402}
13403
13404func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13405	ret := make(graphql.Array, len(v))
13406	var wg sync.WaitGroup
13407	isLen1 := len(v) == 1
13408	if !isLen1 {
13409		wg.Add(len(v))
13410	}
13411	for i := range v {
13412		i := i
13413		fc := &graphql.FieldContext{
13414			Index:  &i,
13415			Result: &v[i],
13416		}
13417		ctx := graphql.WithFieldContext(ctx, fc)
13418		f := func(i int) {
13419			defer func() {
13420				if r := recover(); r != nil {
13421					ec.Error(ctx, ec.Recover(ctx, r))
13422					ret = nil
13423				}
13424			}()
13425			if !isLen1 {
13426				defer wg.Done()
13427			}
13428			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13429		}
13430		if isLen1 {
13431			f(i)
13432		} else {
13433			go f(i)
13434		}
13435
13436	}
13437	wg.Wait()
13438	return ret
13439}
13440
13441func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13442	if v == nil {
13443		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13444			ec.Errorf(ctx, "must not be null")
13445		}
13446		return graphql.Null
13447	}
13448	return ec._CommentEdge(ctx, sel, v)
13449}
13450
13451func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13452	return ec._CommentHistoryStep(ctx, sel, &v)
13453}
13454
13455func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStepᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13456	ret := make(graphql.Array, len(v))
13457	var wg sync.WaitGroup
13458	isLen1 := len(v) == 1
13459	if !isLen1 {
13460		wg.Add(len(v))
13461	}
13462	for i := range v {
13463		i := i
13464		fc := &graphql.FieldContext{
13465			Index:  &i,
13466			Result: &v[i],
13467		}
13468		ctx := graphql.WithFieldContext(ctx, fc)
13469		f := func(i int) {
13470			defer func() {
13471				if r := recover(); r != nil {
13472					ec.Error(ctx, ec.Recover(ctx, r))
13473					ret = nil
13474				}
13475			}()
13476			if !isLen1 {
13477				defer wg.Done()
13478			}
13479			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13480		}
13481		if isLen1 {
13482			f(i)
13483		} else {
13484			go f(i)
13485		}
13486
13487	}
13488	wg.Wait()
13489	return ret
13490}
13491
13492func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13493	return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13494}
13495
13496func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13497	return ec._CommitAsNeededPayload(ctx, sel, &v)
13498}
13499
13500func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13501	if v == nil {
13502		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13503			ec.Errorf(ctx, "must not be null")
13504		}
13505		return graphql.Null
13506	}
13507	return ec._CommitAsNeededPayload(ctx, sel, v)
13508}
13509
13510func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13511	return ec.unmarshalInputCommitInput(ctx, v)
13512}
13513
13514func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13515	return ec._CommitPayload(ctx, sel, &v)
13516}
13517
13518func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13519	if v == nil {
13520		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13521			ec.Errorf(ctx, "must not be null")
13522		}
13523		return graphql.Null
13524	}
13525	return ec._CommitPayload(ctx, sel, v)
13526}
13527
13528func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13529	return ec._CreateOperation(ctx, sel, &v)
13530}
13531
13532func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13533	if v == nil {
13534		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13535			ec.Errorf(ctx, "must not be null")
13536		}
13537		return graphql.Null
13538	}
13539	return ec._CreateOperation(ctx, sel, v)
13540}
13541
13542func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13543	var res git.Hash
13544	return res, res.UnmarshalGQL(v)
13545}
13546
13547func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13548	return v
13549}
13550
13551func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
13552	var vSlice []interface{}
13553	if v != nil {
13554		if tmp1, ok := v.([]interface{}); ok {
13555			vSlice = tmp1
13556		} else {
13557			vSlice = []interface{}{v}
13558		}
13559	}
13560	var err error
13561	res := make([]git.Hash, len(vSlice))
13562	for i := range vSlice {
13563		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13564		if err != nil {
13565			return nil, err
13566		}
13567	}
13568	return res, nil
13569}
13570
13571func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13572	ret := make(graphql.Array, len(v))
13573	for i := range v {
13574		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13575	}
13576
13577	return ret
13578}
13579
13580func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
13581	if v == nil {
13582		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13583			ec.Errorf(ctx, "must not be null")
13584		}
13585		return graphql.Null
13586	}
13587	return ec._Identity(ctx, sel, v)
13588}
13589
13590func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.IdentityWrapper) graphql.Marshaler {
13591	ret := make(graphql.Array, len(v))
13592	var wg sync.WaitGroup
13593	isLen1 := len(v) == 1
13594	if !isLen1 {
13595		wg.Add(len(v))
13596	}
13597	for i := range v {
13598		i := i
13599		fc := &graphql.FieldContext{
13600			Index:  &i,
13601			Result: &v[i],
13602		}
13603		ctx := graphql.WithFieldContext(ctx, fc)
13604		f := func(i int) {
13605			defer func() {
13606				if r := recover(); r != nil {
13607					ec.Error(ctx, ec.Recover(ctx, r))
13608					ret = nil
13609				}
13610			}()
13611			if !isLen1 {
13612				defer wg.Done()
13613			}
13614			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, sel, v[i])
13615		}
13616		if isLen1 {
13617			f(i)
13618		} else {
13619			go f(i)
13620		}
13621
13622	}
13623	wg.Wait()
13624	return ret
13625}
13626
13627func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13628	return ec._IdentityConnection(ctx, sel, &v)
13629}
13630
13631func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13632	if v == nil {
13633		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13634			ec.Errorf(ctx, "must not be null")
13635		}
13636		return graphql.Null
13637	}
13638	return ec._IdentityConnection(ctx, sel, v)
13639}
13640
13641func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13642	return ec._IdentityEdge(ctx, sel, &v)
13643}
13644
13645func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13646	ret := make(graphql.Array, len(v))
13647	var wg sync.WaitGroup
13648	isLen1 := len(v) == 1
13649	if !isLen1 {
13650		wg.Add(len(v))
13651	}
13652	for i := range v {
13653		i := i
13654		fc := &graphql.FieldContext{
13655			Index:  &i,
13656			Result: &v[i],
13657		}
13658		ctx := graphql.WithFieldContext(ctx, fc)
13659		f := func(i int) {
13660			defer func() {
13661				if r := recover(); r != nil {
13662					ec.Error(ctx, ec.Recover(ctx, r))
13663					ret = nil
13664				}
13665			}()
13666			if !isLen1 {
13667				defer wg.Done()
13668			}
13669			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13670		}
13671		if isLen1 {
13672			f(i)
13673		} else {
13674			go f(i)
13675		}
13676
13677	}
13678	wg.Wait()
13679	return ret
13680}
13681
13682func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) 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._IdentityEdge(ctx, sel, v)
13690}
13691
13692func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13693	return graphql.UnmarshalInt(v)
13694}
13695
13696func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13697	res := graphql.MarshalInt(v)
13698	if res == graphql.Null {
13699		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13700			ec.Errorf(ctx, "must not be null")
13701		}
13702	}
13703	return res
13704}
13705
13706func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13707	return ec._Label(ctx, sel, &v)
13708}
13709
13710func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13711	ret := make(graphql.Array, len(v))
13712	var wg sync.WaitGroup
13713	isLen1 := len(v) == 1
13714	if !isLen1 {
13715		wg.Add(len(v))
13716	}
13717	for i := range v {
13718		i := i
13719		fc := &graphql.FieldContext{
13720			Index:  &i,
13721			Result: &v[i],
13722		}
13723		ctx := graphql.WithFieldContext(ctx, fc)
13724		f := func(i int) {
13725			defer func() {
13726				if r := recover(); r != nil {
13727					ec.Error(ctx, ec.Recover(ctx, r))
13728					ret = nil
13729				}
13730			}()
13731			if !isLen1 {
13732				defer wg.Done()
13733			}
13734			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13735		}
13736		if isLen1 {
13737			f(i)
13738		} else {
13739			go f(i)
13740		}
13741
13742	}
13743	wg.Wait()
13744	return ret
13745}
13746
13747func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13748	return ec._LabelChangeOperation(ctx, sel, &v)
13749}
13750
13751func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13752	if v == nil {
13753		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13754			ec.Errorf(ctx, "must not be null")
13755		}
13756		return graphql.Null
13757	}
13758	return ec._LabelChangeOperation(ctx, sel, v)
13759}
13760
13761func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13762	ret := make(graphql.Array, len(v))
13763	var wg sync.WaitGroup
13764	isLen1 := len(v) == 1
13765	if !isLen1 {
13766		wg.Add(len(v))
13767	}
13768	for i := range v {
13769		i := i
13770		fc := &graphql.FieldContext{
13771			Index:  &i,
13772			Result: &v[i],
13773		}
13774		ctx := graphql.WithFieldContext(ctx, fc)
13775		f := func(i int) {
13776			defer func() {
13777				if r := recover(); r != nil {
13778					ec.Error(ctx, ec.Recover(ctx, r))
13779					ret = nil
13780				}
13781			}()
13782			if !isLen1 {
13783				defer wg.Done()
13784			}
13785			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13786		}
13787		if isLen1 {
13788			f(i)
13789		} else {
13790			go f(i)
13791		}
13792
13793	}
13794	wg.Wait()
13795	return ret
13796}
13797
13798func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13799	var res models.LabelChangeStatus
13800	return res, res.UnmarshalGQL(v)
13801}
13802
13803func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13804	return v
13805}
13806
13807func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
13808	return ec._LabelConnection(ctx, sel, &v)
13809}
13810
13811func (ec *executionContext) marshalNLabelConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v *models.LabelConnection) 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._LabelConnection(ctx, sel, v)
13819}
13820
13821func (ec *executionContext) marshalNLabelEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v models.LabelEdge) graphql.Marshaler {
13822	return ec._LabelEdge(ctx, sel, &v)
13823}
13824
13825func (ec *executionContext) marshalNLabelEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LabelEdge) graphql.Marshaler {
13826	ret := make(graphql.Array, len(v))
13827	var wg sync.WaitGroup
13828	isLen1 := len(v) == 1
13829	if !isLen1 {
13830		wg.Add(len(v))
13831	}
13832	for i := range v {
13833		i := i
13834		fc := &graphql.FieldContext{
13835			Index:  &i,
13836			Result: &v[i],
13837		}
13838		ctx := graphql.WithFieldContext(ctx, fc)
13839		f := func(i int) {
13840			defer func() {
13841				if r := recover(); r != nil {
13842					ec.Error(ctx, ec.Recover(ctx, r))
13843					ret = nil
13844				}
13845			}()
13846			if !isLen1 {
13847				defer wg.Done()
13848			}
13849			ret[i] = ec.marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx, sel, v[i])
13850		}
13851		if isLen1 {
13852			f(i)
13853		} else {
13854			go f(i)
13855		}
13856
13857	}
13858	wg.Wait()
13859	return ret
13860}
13861
13862func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelEdge(ctx context.Context, sel ast.SelectionSet, v *models.LabelEdge) graphql.Marshaler {
13863	if v == nil {
13864		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13865			ec.Errorf(ctx, "must not be null")
13866		}
13867		return graphql.Null
13868	}
13869	return ec._LabelEdge(ctx, sel, v)
13870}
13871
13872func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13873	return ec.unmarshalInputNewBugInput(ctx, v)
13874}
13875
13876func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13877	return ec._NewBugPayload(ctx, sel, &v)
13878}
13879
13880func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13881	if v == nil {
13882		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13883			ec.Errorf(ctx, "must not be null")
13884		}
13885		return graphql.Null
13886	}
13887	return ec._NewBugPayload(ctx, sel, v)
13888}
13889
13890func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13891	return ec.unmarshalInputOpenBugInput(ctx, v)
13892}
13893
13894func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13895	return ec._OpenBugPayload(ctx, sel, &v)
13896}
13897
13898func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13899	if v == nil {
13900		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13901			ec.Errorf(ctx, "must not be null")
13902		}
13903		return graphql.Null
13904	}
13905	return ec._OpenBugPayload(ctx, sel, v)
13906}
13907
13908func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13909	if v == nil {
13910		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13911			ec.Errorf(ctx, "must not be null")
13912		}
13913		return graphql.Null
13914	}
13915	return ec._Operation(ctx, sel, v)
13916}
13917
13918func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13919	ret := make(graphql.Array, len(v))
13920	var wg sync.WaitGroup
13921	isLen1 := len(v) == 1
13922	if !isLen1 {
13923		wg.Add(len(v))
13924	}
13925	for i := range v {
13926		i := i
13927		fc := &graphql.FieldContext{
13928			Index:  &i,
13929			Result: &v[i],
13930		}
13931		ctx := graphql.WithFieldContext(ctx, fc)
13932		f := func(i int) {
13933			defer func() {
13934				if r := recover(); r != nil {
13935					ec.Error(ctx, ec.Recover(ctx, r))
13936					ret = nil
13937				}
13938			}()
13939			if !isLen1 {
13940				defer wg.Done()
13941			}
13942			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13943		}
13944		if isLen1 {
13945			f(i)
13946		} else {
13947			go f(i)
13948		}
13949
13950	}
13951	wg.Wait()
13952	return ret
13953}
13954
13955func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13956	return ec._OperationConnection(ctx, sel, &v)
13957}
13958
13959func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13960	if v == nil {
13961		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
13962			ec.Errorf(ctx, "must not be null")
13963		}
13964		return graphql.Null
13965	}
13966	return ec._OperationConnection(ctx, sel, v)
13967}
13968
13969func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13970	return ec._OperationEdge(ctx, sel, &v)
13971}
13972
13973func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13974	ret := make(graphql.Array, len(v))
13975	var wg sync.WaitGroup
13976	isLen1 := len(v) == 1
13977	if !isLen1 {
13978		wg.Add(len(v))
13979	}
13980	for i := range v {
13981		i := i
13982		fc := &graphql.FieldContext{
13983			Index:  &i,
13984			Result: &v[i],
13985		}
13986		ctx := graphql.WithFieldContext(ctx, fc)
13987		f := func(i int) {
13988			defer func() {
13989				if r := recover(); r != nil {
13990					ec.Error(ctx, ec.Recover(ctx, r))
13991					ret = nil
13992				}
13993			}()
13994			if !isLen1 {
13995				defer wg.Done()
13996			}
13997			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13998		}
13999		if isLen1 {
14000			f(i)
14001		} else {
14002			go f(i)
14003		}
14004
14005	}
14006	wg.Wait()
14007	return ret
14008}
14009
14010func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
14011	if v == nil {
14012		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14013			ec.Errorf(ctx, "must not be null")
14014		}
14015		return graphql.Null
14016	}
14017	return ec._OperationEdge(ctx, sel, v)
14018}
14019
14020func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
14021	return ec._PageInfo(ctx, sel, &v)
14022}
14023
14024func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
14025	if v == nil {
14026		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14027			ec.Errorf(ctx, "must not be null")
14028		}
14029		return graphql.Null
14030	}
14031	return ec._PageInfo(ctx, sel, v)
14032}
14033
14034func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
14035	return ec._SetStatusOperation(ctx, sel, &v)
14036}
14037
14038func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14039	if v == nil {
14040		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14041			ec.Errorf(ctx, "must not be null")
14042		}
14043		return graphql.Null
14044	}
14045	return ec._SetStatusOperation(ctx, sel, v)
14046}
14047
14048func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14049	return ec.unmarshalInputSetTitleInput(ctx, v)
14050}
14051
14052func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14053	return ec._SetTitleOperation(ctx, sel, &v)
14054}
14055
14056func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) 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._SetTitleOperation(ctx, sel, v)
14064}
14065
14066func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14067	return ec._SetTitlePayload(ctx, sel, &v)
14068}
14069
14070func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14071	if v == nil {
14072		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14073			ec.Errorf(ctx, "must not be null")
14074		}
14075		return graphql.Null
14076	}
14077	return ec._SetTitlePayload(ctx, sel, v)
14078}
14079
14080func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14081	var res models.Status
14082	return res, res.UnmarshalGQL(v)
14083}
14084
14085func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14086	return v
14087}
14088
14089func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14090	return graphql.UnmarshalString(v)
14091}
14092
14093func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14094	res := graphql.MarshalString(v)
14095	if res == graphql.Null {
14096		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14097			ec.Errorf(ctx, "must not be null")
14098		}
14099	}
14100	return res
14101}
14102
14103func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14104	return graphql.UnmarshalTime(v)
14105}
14106
14107func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14108	res := graphql.MarshalTime(v)
14109	if res == graphql.Null {
14110		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14111			ec.Errorf(ctx, "must not be null")
14112		}
14113	}
14114	return res
14115}
14116
14117func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14118	if v == nil {
14119		return nil, nil
14120	}
14121	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14122	return &res, err
14123}
14124
14125func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14126	if v == nil {
14127		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14128			ec.Errorf(ctx, "must not be null")
14129		}
14130		return graphql.Null
14131	}
14132	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14133}
14134
14135func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14136	if v == nil {
14137		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14138			ec.Errorf(ctx, "must not be null")
14139		}
14140		return graphql.Null
14141	}
14142	return ec._TimelineItem(ctx, sel, v)
14143}
14144
14145func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14146	ret := make(graphql.Array, len(v))
14147	var wg sync.WaitGroup
14148	isLen1 := len(v) == 1
14149	if !isLen1 {
14150		wg.Add(len(v))
14151	}
14152	for i := range v {
14153		i := i
14154		fc := &graphql.FieldContext{
14155			Index:  &i,
14156			Result: &v[i],
14157		}
14158		ctx := graphql.WithFieldContext(ctx, fc)
14159		f := func(i int) {
14160			defer func() {
14161				if r := recover(); r != nil {
14162					ec.Error(ctx, ec.Recover(ctx, r))
14163					ret = nil
14164				}
14165			}()
14166			if !isLen1 {
14167				defer wg.Done()
14168			}
14169			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14170		}
14171		if isLen1 {
14172			f(i)
14173		} else {
14174			go f(i)
14175		}
14176
14177	}
14178	wg.Wait()
14179	return ret
14180}
14181
14182func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14183	return ec._TimelineItemConnection(ctx, sel, &v)
14184}
14185
14186func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14187	if v == nil {
14188		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14189			ec.Errorf(ctx, "must not be null")
14190		}
14191		return graphql.Null
14192	}
14193	return ec._TimelineItemConnection(ctx, sel, v)
14194}
14195
14196func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14197	return ec._TimelineItemEdge(ctx, sel, &v)
14198}
14199
14200func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14201	ret := make(graphql.Array, len(v))
14202	var wg sync.WaitGroup
14203	isLen1 := len(v) == 1
14204	if !isLen1 {
14205		wg.Add(len(v))
14206	}
14207	for i := range v {
14208		i := i
14209		fc := &graphql.FieldContext{
14210			Index:  &i,
14211			Result: &v[i],
14212		}
14213		ctx := graphql.WithFieldContext(ctx, fc)
14214		f := func(i int) {
14215			defer func() {
14216				if r := recover(); r != nil {
14217					ec.Error(ctx, ec.Recover(ctx, r))
14218					ret = nil
14219				}
14220			}()
14221			if !isLen1 {
14222				defer wg.Done()
14223			}
14224			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14225		}
14226		if isLen1 {
14227			f(i)
14228		} else {
14229			go f(i)
14230		}
14231
14232	}
14233	wg.Wait()
14234	return ret
14235}
14236
14237func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14238	if v == nil {
14239		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14240			ec.Errorf(ctx, "must not be null")
14241		}
14242		return graphql.Null
14243	}
14244	return ec._TimelineItemEdge(ctx, sel, v)
14245}
14246
14247func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14248	return ec.___Directive(ctx, sel, &v)
14249}
14250
14251func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14252	ret := make(graphql.Array, len(v))
14253	var wg sync.WaitGroup
14254	isLen1 := len(v) == 1
14255	if !isLen1 {
14256		wg.Add(len(v))
14257	}
14258	for i := range v {
14259		i := i
14260		fc := &graphql.FieldContext{
14261			Index:  &i,
14262			Result: &v[i],
14263		}
14264		ctx := graphql.WithFieldContext(ctx, fc)
14265		f := func(i int) {
14266			defer func() {
14267				if r := recover(); r != nil {
14268					ec.Error(ctx, ec.Recover(ctx, r))
14269					ret = nil
14270				}
14271			}()
14272			if !isLen1 {
14273				defer wg.Done()
14274			}
14275			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14276		}
14277		if isLen1 {
14278			f(i)
14279		} else {
14280			go f(i)
14281		}
14282
14283	}
14284	wg.Wait()
14285	return ret
14286}
14287
14288func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14289	return graphql.UnmarshalString(v)
14290}
14291
14292func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14293	res := graphql.MarshalString(v)
14294	if res == graphql.Null {
14295		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14296			ec.Errorf(ctx, "must not be null")
14297		}
14298	}
14299	return res
14300}
14301
14302func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14303	var vSlice []interface{}
14304	if v != nil {
14305		if tmp1, ok := v.([]interface{}); ok {
14306			vSlice = tmp1
14307		} else {
14308			vSlice = []interface{}{v}
14309		}
14310	}
14311	var err error
14312	res := make([]string, len(vSlice))
14313	for i := range vSlice {
14314		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14315		if err != nil {
14316			return nil, err
14317		}
14318	}
14319	return res, nil
14320}
14321
14322func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14323	ret := make(graphql.Array, len(v))
14324	var wg sync.WaitGroup
14325	isLen1 := len(v) == 1
14326	if !isLen1 {
14327		wg.Add(len(v))
14328	}
14329	for i := range v {
14330		i := i
14331		fc := &graphql.FieldContext{
14332			Index:  &i,
14333			Result: &v[i],
14334		}
14335		ctx := graphql.WithFieldContext(ctx, fc)
14336		f := func(i int) {
14337			defer func() {
14338				if r := recover(); r != nil {
14339					ec.Error(ctx, ec.Recover(ctx, r))
14340					ret = nil
14341				}
14342			}()
14343			if !isLen1 {
14344				defer wg.Done()
14345			}
14346			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14347		}
14348		if isLen1 {
14349			f(i)
14350		} else {
14351			go f(i)
14352		}
14353
14354	}
14355	wg.Wait()
14356	return ret
14357}
14358
14359func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14360	return ec.___EnumValue(ctx, sel, &v)
14361}
14362
14363func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14364	return ec.___Field(ctx, sel, &v)
14365}
14366
14367func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14368	return ec.___InputValue(ctx, sel, &v)
14369}
14370
14371func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14372	ret := make(graphql.Array, len(v))
14373	var wg sync.WaitGroup
14374	isLen1 := len(v) == 1
14375	if !isLen1 {
14376		wg.Add(len(v))
14377	}
14378	for i := range v {
14379		i := i
14380		fc := &graphql.FieldContext{
14381			Index:  &i,
14382			Result: &v[i],
14383		}
14384		ctx := graphql.WithFieldContext(ctx, fc)
14385		f := func(i int) {
14386			defer func() {
14387				if r := recover(); r != nil {
14388					ec.Error(ctx, ec.Recover(ctx, r))
14389					ret = nil
14390				}
14391			}()
14392			if !isLen1 {
14393				defer wg.Done()
14394			}
14395			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14396		}
14397		if isLen1 {
14398			f(i)
14399		} else {
14400			go f(i)
14401		}
14402
14403	}
14404	wg.Wait()
14405	return ret
14406}
14407
14408func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14409	return ec.___Type(ctx, sel, &v)
14410}
14411
14412func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14413	ret := make(graphql.Array, len(v))
14414	var wg sync.WaitGroup
14415	isLen1 := len(v) == 1
14416	if !isLen1 {
14417		wg.Add(len(v))
14418	}
14419	for i := range v {
14420		i := i
14421		fc := &graphql.FieldContext{
14422			Index:  &i,
14423			Result: &v[i],
14424		}
14425		ctx := graphql.WithFieldContext(ctx, fc)
14426		f := func(i int) {
14427			defer func() {
14428				if r := recover(); r != nil {
14429					ec.Error(ctx, ec.Recover(ctx, r))
14430					ret = nil
14431				}
14432			}()
14433			if !isLen1 {
14434				defer wg.Done()
14435			}
14436			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14437		}
14438		if isLen1 {
14439			f(i)
14440		} else {
14441			go f(i)
14442		}
14443
14444	}
14445	wg.Wait()
14446	return ret
14447}
14448
14449func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14450	if v == nil {
14451		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14452			ec.Errorf(ctx, "must not be null")
14453		}
14454		return graphql.Null
14455	}
14456	return ec.___Type(ctx, sel, v)
14457}
14458
14459func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14460	return graphql.UnmarshalString(v)
14461}
14462
14463func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14464	res := graphql.MarshalString(v)
14465	if res == graphql.Null {
14466		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
14467			ec.Errorf(ctx, "must not be null")
14468		}
14469	}
14470	return res
14471}
14472
14473func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14474	return graphql.UnmarshalBoolean(v)
14475}
14476
14477func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14478	return graphql.MarshalBoolean(v)
14479}
14480
14481func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14482	if v == nil {
14483		return nil, nil
14484	}
14485	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14486	return &res, err
14487}
14488
14489func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14490	if v == nil {
14491		return graphql.Null
14492	}
14493	return ec.marshalOBoolean2bool(ctx, sel, *v)
14494}
14495
14496func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
14497	if v == nil {
14498		return graphql.Null
14499	}
14500	return ec._Bug(ctx, sel, v)
14501}
14502
14503func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14504	return ec.unmarshalInputChangeLabelInput(ctx, v)
14505}
14506
14507func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14508	if v == nil {
14509		return nil, nil
14510	}
14511	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14512	return &res, err
14513}
14514
14515func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, v interface{}) ([]git.Hash, error) {
14516	var vSlice []interface{}
14517	if v != nil {
14518		if tmp1, ok := v.([]interface{}); ok {
14519			vSlice = tmp1
14520		} else {
14521			vSlice = []interface{}{v}
14522		}
14523	}
14524	var err error
14525	res := make([]git.Hash, len(vSlice))
14526	for i := range vSlice {
14527		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14528		if err != nil {
14529			return nil, err
14530		}
14531	}
14532	return res, nil
14533}
14534
14535func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHashᚄ(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14536	if v == nil {
14537		return graphql.Null
14538	}
14539	ret := make(graphql.Array, len(v))
14540	for i := range v {
14541		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14542	}
14543
14544	return ret
14545}
14546
14547func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx context.Context, sel ast.SelectionSet, v models.IdentityWrapper) graphql.Marshaler {
14548	if v == nil {
14549		return graphql.Null
14550	}
14551	return ec._Identity(ctx, sel, v)
14552}
14553
14554func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14555	return graphql.UnmarshalInt(v)
14556}
14557
14558func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14559	return graphql.MarshalInt(v)
14560}
14561
14562func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14563	if v == nil {
14564		return nil, nil
14565	}
14566	res, err := ec.unmarshalOInt2int(ctx, v)
14567	return &res, err
14568}
14569
14570func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14571	if v == nil {
14572		return graphql.Null
14573	}
14574	return ec.marshalOInt2int(ctx, sel, *v)
14575}
14576
14577func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14578	return ec._LabelChangeResult(ctx, sel, &v)
14579}
14580
14581func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14582	if v == nil {
14583		return graphql.Null
14584	}
14585	return ec._LabelChangeResult(ctx, sel, v)
14586}
14587
14588func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14589	return ec._Repository(ctx, sel, &v)
14590}
14591
14592func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14593	if v == nil {
14594		return graphql.Null
14595	}
14596	return ec._Repository(ctx, sel, v)
14597}
14598
14599func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14600	return graphql.UnmarshalString(v)
14601}
14602
14603func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14604	return graphql.MarshalString(v)
14605}
14606
14607func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
14608	var vSlice []interface{}
14609	if v != nil {
14610		if tmp1, ok := v.([]interface{}); ok {
14611			vSlice = tmp1
14612		} else {
14613			vSlice = []interface{}{v}
14614		}
14615	}
14616	var err error
14617	res := make([]string, len(vSlice))
14618	for i := range vSlice {
14619		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14620		if err != nil {
14621			return nil, err
14622		}
14623	}
14624	return res, nil
14625}
14626
14627func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14628	if v == nil {
14629		return graphql.Null
14630	}
14631	ret := make(graphql.Array, len(v))
14632	for i := range v {
14633		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14634	}
14635
14636	return ret
14637}
14638
14639func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14640	if v == nil {
14641		return nil, nil
14642	}
14643	res, err := ec.unmarshalOString2string(ctx, v)
14644	return &res, err
14645}
14646
14647func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14648	if v == nil {
14649		return graphql.Null
14650	}
14651	return ec.marshalOString2string(ctx, sel, *v)
14652}
14653
14654func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14655	if v == nil {
14656		return graphql.Null
14657	}
14658	ret := make(graphql.Array, len(v))
14659	var wg sync.WaitGroup
14660	isLen1 := len(v) == 1
14661	if !isLen1 {
14662		wg.Add(len(v))
14663	}
14664	for i := range v {
14665		i := i
14666		fc := &graphql.FieldContext{
14667			Index:  &i,
14668			Result: &v[i],
14669		}
14670		ctx := graphql.WithFieldContext(ctx, fc)
14671		f := func(i int) {
14672			defer func() {
14673				if r := recover(); r != nil {
14674					ec.Error(ctx, ec.Recover(ctx, r))
14675					ret = nil
14676				}
14677			}()
14678			if !isLen1 {
14679				defer wg.Done()
14680			}
14681			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14682		}
14683		if isLen1 {
14684			f(i)
14685		} else {
14686			go f(i)
14687		}
14688
14689	}
14690	wg.Wait()
14691	return ret
14692}
14693
14694func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14695	if v == nil {
14696		return graphql.Null
14697	}
14698	ret := make(graphql.Array, len(v))
14699	var wg sync.WaitGroup
14700	isLen1 := len(v) == 1
14701	if !isLen1 {
14702		wg.Add(len(v))
14703	}
14704	for i := range v {
14705		i := i
14706		fc := &graphql.FieldContext{
14707			Index:  &i,
14708			Result: &v[i],
14709		}
14710		ctx := graphql.WithFieldContext(ctx, fc)
14711		f := func(i int) {
14712			defer func() {
14713				if r := recover(); r != nil {
14714					ec.Error(ctx, ec.Recover(ctx, r))
14715					ret = nil
14716				}
14717			}()
14718			if !isLen1 {
14719				defer wg.Done()
14720			}
14721			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14722		}
14723		if isLen1 {
14724			f(i)
14725		} else {
14726			go f(i)
14727		}
14728
14729	}
14730	wg.Wait()
14731	return ret
14732}
14733
14734func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14735	if v == nil {
14736		return graphql.Null
14737	}
14738	ret := make(graphql.Array, len(v))
14739	var wg sync.WaitGroup
14740	isLen1 := len(v) == 1
14741	if !isLen1 {
14742		wg.Add(len(v))
14743	}
14744	for i := range v {
14745		i := i
14746		fc := &graphql.FieldContext{
14747			Index:  &i,
14748			Result: &v[i],
14749		}
14750		ctx := graphql.WithFieldContext(ctx, fc)
14751		f := func(i int) {
14752			defer func() {
14753				if r := recover(); r != nil {
14754					ec.Error(ctx, ec.Recover(ctx, r))
14755					ret = nil
14756				}
14757			}()
14758			if !isLen1 {
14759				defer wg.Done()
14760			}
14761			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14762		}
14763		if isLen1 {
14764			f(i)
14765		} else {
14766			go f(i)
14767		}
14768
14769	}
14770	wg.Wait()
14771	return ret
14772}
14773
14774func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14775	return ec.___Schema(ctx, sel, &v)
14776}
14777
14778func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14779	if v == nil {
14780		return graphql.Null
14781	}
14782	return ec.___Schema(ctx, sel, v)
14783}
14784
14785func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14786	return ec.___Type(ctx, sel, &v)
14787}
14788
14789func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14790	if v == nil {
14791		return graphql.Null
14792	}
14793	ret := make(graphql.Array, len(v))
14794	var wg sync.WaitGroup
14795	isLen1 := len(v) == 1
14796	if !isLen1 {
14797		wg.Add(len(v))
14798	}
14799	for i := range v {
14800		i := i
14801		fc := &graphql.FieldContext{
14802			Index:  &i,
14803			Result: &v[i],
14804		}
14805		ctx := graphql.WithFieldContext(ctx, fc)
14806		f := func(i int) {
14807			defer func() {
14808				if r := recover(); r != nil {
14809					ec.Error(ctx, ec.Recover(ctx, r))
14810					ret = nil
14811				}
14812			}()
14813			if !isLen1 {
14814				defer wg.Done()
14815			}
14816			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14817		}
14818		if isLen1 {
14819			f(i)
14820		} else {
14821			go f(i)
14822		}
14823
14824	}
14825	wg.Wait()
14826	return ret
14827}
14828
14829func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14830	if v == nil {
14831		return graphql.Null
14832	}
14833	return ec.___Type(ctx, sel, v)
14834}
14835
14836// endregion ***************************** type.gotpl *****************************