1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"context"
   7	"fmt"
   8	"strconv"
   9	"sync/atomic"
  10
  11	"github.com/99designs/gqlgen/graphql"
  12	"github.com/99designs/gqlgen/graphql/introspection"
  13	"github.com/git-bug/git-bug/api/graphql/models"
  14	"github.com/vektah/gqlparser/v2/ast"
  15)
  16
  17// region    ************************** generated!.gotpl **************************
  18
  19type MutationResolver interface {
  20	BugCreate(ctx context.Context, input models.BugCreateInput) (*models.BugCreatePayload, error)
  21	BugAddComment(ctx context.Context, input models.BugAddCommentInput) (*models.BugAddCommentPayload, error)
  22	BugAddCommentAndClose(ctx context.Context, input models.BugAddCommentAndCloseInput) (*models.BugAddCommentAndClosePayload, error)
  23	BugAddCommentAndReopen(ctx context.Context, input models.BugAddCommentAndReopenInput) (*models.BugAddCommentAndReopenPayload, error)
  24	BugEditComment(ctx context.Context, input models.BugEditCommentInput) (*models.BugEditCommentPayload, error)
  25	BugChangeLabels(ctx context.Context, input *models.BugChangeLabelInput) (*models.BugChangeLabelPayload, error)
  26	BugStatusOpen(ctx context.Context, input models.BugStatusOpenInput) (*models.BugStatusOpenPayload, error)
  27	BugStatusClose(ctx context.Context, input models.BugStatusCloseInput) (*models.BugStatusClosePayload, error)
  28	BugSetTitle(ctx context.Context, input models.BugSetTitleInput) (*models.BugSetTitlePayload, error)
  29}
  30type QueryResolver interface {
  31	Repository(ctx context.Context, ref *string) (*models.Repository, error)
  32	Repositories(ctx context.Context, after *string, before *string, first *int, last *int) (*models.RepositoryConnection, error)
  33}
  34
  35// endregion ************************** generated!.gotpl **************************
  36
  37// region    ***************************** args.gotpl *****************************
  38
  39func (ec *executionContext) field_Mutation_bugAddCommentAndClose_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  40	var err error
  41	args := map[string]any{}
  42	arg0, err := ec.field_Mutation_bugAddCommentAndClose_argsInput(ctx, rawArgs)
  43	if err != nil {
  44		return nil, err
  45	}
  46	args["input"] = arg0
  47	return args, nil
  48}
  49func (ec *executionContext) field_Mutation_bugAddCommentAndClose_argsInput(
  50	ctx context.Context,
  51	rawArgs map[string]any,
  52) (models.BugAddCommentAndCloseInput, error) {
  53	if _, ok := rawArgs["input"]; !ok {
  54		var zeroVal models.BugAddCommentAndCloseInput
  55		return zeroVal, nil
  56	}
  57
  58	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
  59	if tmp, ok := rawArgs["input"]; ok {
  60		return ec.unmarshalNBugAddCommentAndCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndCloseInput(ctx, tmp)
  61	}
  62
  63	var zeroVal models.BugAddCommentAndCloseInput
  64	return zeroVal, nil
  65}
  66
  67func (ec *executionContext) field_Mutation_bugAddCommentAndReopen_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  68	var err error
  69	args := map[string]any{}
  70	arg0, err := ec.field_Mutation_bugAddCommentAndReopen_argsInput(ctx, rawArgs)
  71	if err != nil {
  72		return nil, err
  73	}
  74	args["input"] = arg0
  75	return args, nil
  76}
  77func (ec *executionContext) field_Mutation_bugAddCommentAndReopen_argsInput(
  78	ctx context.Context,
  79	rawArgs map[string]any,
  80) (models.BugAddCommentAndReopenInput, error) {
  81	if _, ok := rawArgs["input"]; !ok {
  82		var zeroVal models.BugAddCommentAndReopenInput
  83		return zeroVal, nil
  84	}
  85
  86	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
  87	if tmp, ok := rawArgs["input"]; ok {
  88		return ec.unmarshalNBugAddCommentAndReopenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenInput(ctx, tmp)
  89	}
  90
  91	var zeroVal models.BugAddCommentAndReopenInput
  92	return zeroVal, nil
  93}
  94
  95func (ec *executionContext) field_Mutation_bugAddComment_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  96	var err error
  97	args := map[string]any{}
  98	arg0, err := ec.field_Mutation_bugAddComment_argsInput(ctx, rawArgs)
  99	if err != nil {
 100		return nil, err
 101	}
 102	args["input"] = arg0
 103	return args, nil
 104}
 105func (ec *executionContext) field_Mutation_bugAddComment_argsInput(
 106	ctx context.Context,
 107	rawArgs map[string]any,
 108) (models.BugAddCommentInput, error) {
 109	if _, ok := rawArgs["input"]; !ok {
 110		var zeroVal models.BugAddCommentInput
 111		return zeroVal, nil
 112	}
 113
 114	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 115	if tmp, ok := rawArgs["input"]; ok {
 116		return ec.unmarshalNBugAddCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentInput(ctx, tmp)
 117	}
 118
 119	var zeroVal models.BugAddCommentInput
 120	return zeroVal, nil
 121}
 122
 123func (ec *executionContext) field_Mutation_bugChangeLabels_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 124	var err error
 125	args := map[string]any{}
 126	arg0, err := ec.field_Mutation_bugChangeLabels_argsInput(ctx, rawArgs)
 127	if err != nil {
 128		return nil, err
 129	}
 130	args["input"] = arg0
 131	return args, nil
 132}
 133func (ec *executionContext) field_Mutation_bugChangeLabels_argsInput(
 134	ctx context.Context,
 135	rawArgs map[string]any,
 136) (*models.BugChangeLabelInput, error) {
 137	if _, ok := rawArgs["input"]; !ok {
 138		var zeroVal *models.BugChangeLabelInput
 139		return zeroVal, nil
 140	}
 141
 142	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 143	if tmp, ok := rawArgs["input"]; ok {
 144		return ec.unmarshalOBugChangeLabelInput2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelInput(ctx, tmp)
 145	}
 146
 147	var zeroVal *models.BugChangeLabelInput
 148	return zeroVal, nil
 149}
 150
 151func (ec *executionContext) field_Mutation_bugCreate_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 152	var err error
 153	args := map[string]any{}
 154	arg0, err := ec.field_Mutation_bugCreate_argsInput(ctx, rawArgs)
 155	if err != nil {
 156		return nil, err
 157	}
 158	args["input"] = arg0
 159	return args, nil
 160}
 161func (ec *executionContext) field_Mutation_bugCreate_argsInput(
 162	ctx context.Context,
 163	rawArgs map[string]any,
 164) (models.BugCreateInput, error) {
 165	if _, ok := rawArgs["input"]; !ok {
 166		var zeroVal models.BugCreateInput
 167		return zeroVal, nil
 168	}
 169
 170	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 171	if tmp, ok := rawArgs["input"]; ok {
 172		return ec.unmarshalNBugCreateInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreateInput(ctx, tmp)
 173	}
 174
 175	var zeroVal models.BugCreateInput
 176	return zeroVal, nil
 177}
 178
 179func (ec *executionContext) field_Mutation_bugEditComment_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 180	var err error
 181	args := map[string]any{}
 182	arg0, err := ec.field_Mutation_bugEditComment_argsInput(ctx, rawArgs)
 183	if err != nil {
 184		return nil, err
 185	}
 186	args["input"] = arg0
 187	return args, nil
 188}
 189func (ec *executionContext) field_Mutation_bugEditComment_argsInput(
 190	ctx context.Context,
 191	rawArgs map[string]any,
 192) (models.BugEditCommentInput, error) {
 193	if _, ok := rawArgs["input"]; !ok {
 194		var zeroVal models.BugEditCommentInput
 195		return zeroVal, nil
 196	}
 197
 198	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 199	if tmp, ok := rawArgs["input"]; ok {
 200		return ec.unmarshalNBugEditCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentInput(ctx, tmp)
 201	}
 202
 203	var zeroVal models.BugEditCommentInput
 204	return zeroVal, nil
 205}
 206
 207func (ec *executionContext) field_Mutation_bugSetTitle_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 208	var err error
 209	args := map[string]any{}
 210	arg0, err := ec.field_Mutation_bugSetTitle_argsInput(ctx, rawArgs)
 211	if err != nil {
 212		return nil, err
 213	}
 214	args["input"] = arg0
 215	return args, nil
 216}
 217func (ec *executionContext) field_Mutation_bugSetTitle_argsInput(
 218	ctx context.Context,
 219	rawArgs map[string]any,
 220) (models.BugSetTitleInput, error) {
 221	if _, ok := rawArgs["input"]; !ok {
 222		var zeroVal models.BugSetTitleInput
 223		return zeroVal, nil
 224	}
 225
 226	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 227	if tmp, ok := rawArgs["input"]; ok {
 228		return ec.unmarshalNBugSetTitleInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitleInput(ctx, tmp)
 229	}
 230
 231	var zeroVal models.BugSetTitleInput
 232	return zeroVal, nil
 233}
 234
 235func (ec *executionContext) field_Mutation_bugStatusClose_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 236	var err error
 237	args := map[string]any{}
 238	arg0, err := ec.field_Mutation_bugStatusClose_argsInput(ctx, rawArgs)
 239	if err != nil {
 240		return nil, err
 241	}
 242	args["input"] = arg0
 243	return args, nil
 244}
 245func (ec *executionContext) field_Mutation_bugStatusClose_argsInput(
 246	ctx context.Context,
 247	rawArgs map[string]any,
 248) (models.BugStatusCloseInput, error) {
 249	if _, ok := rawArgs["input"]; !ok {
 250		var zeroVal models.BugStatusCloseInput
 251		return zeroVal, nil
 252	}
 253
 254	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 255	if tmp, ok := rawArgs["input"]; ok {
 256		return ec.unmarshalNBugStatusCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusCloseInput(ctx, tmp)
 257	}
 258
 259	var zeroVal models.BugStatusCloseInput
 260	return zeroVal, nil
 261}
 262
 263func (ec *executionContext) field_Mutation_bugStatusOpen_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 264	var err error
 265	args := map[string]any{}
 266	arg0, err := ec.field_Mutation_bugStatusOpen_argsInput(ctx, rawArgs)
 267	if err != nil {
 268		return nil, err
 269	}
 270	args["input"] = arg0
 271	return args, nil
 272}
 273func (ec *executionContext) field_Mutation_bugStatusOpen_argsInput(
 274	ctx context.Context,
 275	rawArgs map[string]any,
 276) (models.BugStatusOpenInput, error) {
 277	if _, ok := rawArgs["input"]; !ok {
 278		var zeroVal models.BugStatusOpenInput
 279		return zeroVal, nil
 280	}
 281
 282	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
 283	if tmp, ok := rawArgs["input"]; ok {
 284		return ec.unmarshalNBugStatusOpenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenInput(ctx, tmp)
 285	}
 286
 287	var zeroVal models.BugStatusOpenInput
 288	return zeroVal, nil
 289}
 290
 291func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 292	var err error
 293	args := map[string]any{}
 294	arg0, err := ec.field_Query___type_argsName(ctx, rawArgs)
 295	if err != nil {
 296		return nil, err
 297	}
 298	args["name"] = arg0
 299	return args, nil
 300}
 301func (ec *executionContext) field_Query___type_argsName(
 302	ctx context.Context,
 303	rawArgs map[string]any,
 304) (string, error) {
 305	if _, ok := rawArgs["name"]; !ok {
 306		var zeroVal string
 307		return zeroVal, nil
 308	}
 309
 310	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
 311	if tmp, ok := rawArgs["name"]; ok {
 312		return ec.unmarshalNString2string(ctx, tmp)
 313	}
 314
 315	var zeroVal string
 316	return zeroVal, nil
 317}
 318
 319func (ec *executionContext) field_Query_repositories_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 320	var err error
 321	args := map[string]any{}
 322	arg0, err := ec.field_Query_repositories_argsAfter(ctx, rawArgs)
 323	if err != nil {
 324		return nil, err
 325	}
 326	args["after"] = arg0
 327	arg1, err := ec.field_Query_repositories_argsBefore(ctx, rawArgs)
 328	if err != nil {
 329		return nil, err
 330	}
 331	args["before"] = arg1
 332	arg2, err := ec.field_Query_repositories_argsFirst(ctx, rawArgs)
 333	if err != nil {
 334		return nil, err
 335	}
 336	args["first"] = arg2
 337	arg3, err := ec.field_Query_repositories_argsLast(ctx, rawArgs)
 338	if err != nil {
 339		return nil, err
 340	}
 341	args["last"] = arg3
 342	return args, nil
 343}
 344func (ec *executionContext) field_Query_repositories_argsAfter(
 345	ctx context.Context,
 346	rawArgs map[string]any,
 347) (*string, error) {
 348	if _, ok := rawArgs["after"]; !ok {
 349		var zeroVal *string
 350		return zeroVal, nil
 351	}
 352
 353	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 354	if tmp, ok := rawArgs["after"]; ok {
 355		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 356	}
 357
 358	var zeroVal *string
 359	return zeroVal, nil
 360}
 361
 362func (ec *executionContext) field_Query_repositories_argsBefore(
 363	ctx context.Context,
 364	rawArgs map[string]any,
 365) (*string, error) {
 366	if _, ok := rawArgs["before"]; !ok {
 367		var zeroVal *string
 368		return zeroVal, nil
 369	}
 370
 371	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 372	if tmp, ok := rawArgs["before"]; ok {
 373		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 374	}
 375
 376	var zeroVal *string
 377	return zeroVal, nil
 378}
 379
 380func (ec *executionContext) field_Query_repositories_argsFirst(
 381	ctx context.Context,
 382	rawArgs map[string]any,
 383) (*int, error) {
 384	if _, ok := rawArgs["first"]; !ok {
 385		var zeroVal *int
 386		return zeroVal, nil
 387	}
 388
 389	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 390	if tmp, ok := rawArgs["first"]; ok {
 391		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 392	}
 393
 394	var zeroVal *int
 395	return zeroVal, nil
 396}
 397
 398func (ec *executionContext) field_Query_repositories_argsLast(
 399	ctx context.Context,
 400	rawArgs map[string]any,
 401) (*int, error) {
 402	if _, ok := rawArgs["last"]; !ok {
 403		var zeroVal *int
 404		return zeroVal, nil
 405	}
 406
 407	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 408	if tmp, ok := rawArgs["last"]; ok {
 409		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 410	}
 411
 412	var zeroVal *int
 413	return zeroVal, nil
 414}
 415
 416func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 417	var err error
 418	args := map[string]any{}
 419	arg0, err := ec.field_Query_repository_argsRef(ctx, rawArgs)
 420	if err != nil {
 421		return nil, err
 422	}
 423	args["ref"] = arg0
 424	return args, nil
 425}
 426func (ec *executionContext) field_Query_repository_argsRef(
 427	ctx context.Context,
 428	rawArgs map[string]any,
 429) (*string, error) {
 430	if _, ok := rawArgs["ref"]; !ok {
 431		var zeroVal *string
 432		return zeroVal, nil
 433	}
 434
 435	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
 436	if tmp, ok := rawArgs["ref"]; ok {
 437		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 438	}
 439
 440	var zeroVal *string
 441	return zeroVal, nil
 442}
 443
 444// endregion ***************************** args.gotpl *****************************
 445
 446// region    ************************** directives.gotpl **************************
 447
 448// endregion ************************** directives.gotpl **************************
 449
 450// region    **************************** field.gotpl *****************************
 451
 452func (ec *executionContext) _Mutation_bugCreate(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 453	fc, err := ec.fieldContext_Mutation_bugCreate(ctx, field)
 454	if err != nil {
 455		return graphql.Null
 456	}
 457	ctx = graphql.WithFieldContext(ctx, fc)
 458	defer func() {
 459		if r := recover(); r != nil {
 460			ec.Error(ctx, ec.Recover(ctx, r))
 461			ret = graphql.Null
 462		}
 463	}()
 464	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 465		ctx = rctx // use context from middleware stack in children
 466		return ec.resolvers.Mutation().BugCreate(rctx, fc.Args["input"].(models.BugCreateInput))
 467	})
 468	if err != nil {
 469		ec.Error(ctx, err)
 470		return graphql.Null
 471	}
 472	if resTmp == nil {
 473		if !graphql.HasFieldError(ctx, fc) {
 474			ec.Errorf(ctx, "must not be null")
 475		}
 476		return graphql.Null
 477	}
 478	res := resTmp.(*models.BugCreatePayload)
 479	fc.Result = res
 480	return ec.marshalNBugCreatePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreatePayload(ctx, field.Selections, res)
 481}
 482
 483func (ec *executionContext) fieldContext_Mutation_bugCreate(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 484	fc = &graphql.FieldContext{
 485		Object:     "Mutation",
 486		Field:      field,
 487		IsMethod:   true,
 488		IsResolver: true,
 489		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 490			switch field.Name {
 491			case "clientMutationId":
 492				return ec.fieldContext_BugCreatePayload_clientMutationId(ctx, field)
 493			case "bug":
 494				return ec.fieldContext_BugCreatePayload_bug(ctx, field)
 495			case "operation":
 496				return ec.fieldContext_BugCreatePayload_operation(ctx, field)
 497			}
 498			return nil, fmt.Errorf("no field named %q was found under type BugCreatePayload", field.Name)
 499		},
 500	}
 501	defer func() {
 502		if r := recover(); r != nil {
 503			err = ec.Recover(ctx, r)
 504			ec.Error(ctx, err)
 505		}
 506	}()
 507	ctx = graphql.WithFieldContext(ctx, fc)
 508	if fc.Args, err = ec.field_Mutation_bugCreate_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 509		ec.Error(ctx, err)
 510		return fc, err
 511	}
 512	return fc, nil
 513}
 514
 515func (ec *executionContext) _Mutation_bugAddComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 516	fc, err := ec.fieldContext_Mutation_bugAddComment(ctx, field)
 517	if err != nil {
 518		return graphql.Null
 519	}
 520	ctx = graphql.WithFieldContext(ctx, fc)
 521	defer func() {
 522		if r := recover(); r != nil {
 523			ec.Error(ctx, ec.Recover(ctx, r))
 524			ret = graphql.Null
 525		}
 526	}()
 527	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 528		ctx = rctx // use context from middleware stack in children
 529		return ec.resolvers.Mutation().BugAddComment(rctx, fc.Args["input"].(models.BugAddCommentInput))
 530	})
 531	if err != nil {
 532		ec.Error(ctx, err)
 533		return graphql.Null
 534	}
 535	if resTmp == nil {
 536		if !graphql.HasFieldError(ctx, fc) {
 537			ec.Errorf(ctx, "must not be null")
 538		}
 539		return graphql.Null
 540	}
 541	res := resTmp.(*models.BugAddCommentPayload)
 542	fc.Result = res
 543	return ec.marshalNBugAddCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentPayload(ctx, field.Selections, res)
 544}
 545
 546func (ec *executionContext) fieldContext_Mutation_bugAddComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 547	fc = &graphql.FieldContext{
 548		Object:     "Mutation",
 549		Field:      field,
 550		IsMethod:   true,
 551		IsResolver: true,
 552		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 553			switch field.Name {
 554			case "clientMutationId":
 555				return ec.fieldContext_BugAddCommentPayload_clientMutationId(ctx, field)
 556			case "bug":
 557				return ec.fieldContext_BugAddCommentPayload_bug(ctx, field)
 558			case "operation":
 559				return ec.fieldContext_BugAddCommentPayload_operation(ctx, field)
 560			}
 561			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentPayload", field.Name)
 562		},
 563	}
 564	defer func() {
 565		if r := recover(); r != nil {
 566			err = ec.Recover(ctx, r)
 567			ec.Error(ctx, err)
 568		}
 569	}()
 570	ctx = graphql.WithFieldContext(ctx, fc)
 571	if fc.Args, err = ec.field_Mutation_bugAddComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 572		ec.Error(ctx, err)
 573		return fc, err
 574	}
 575	return fc, nil
 576}
 577
 578func (ec *executionContext) _Mutation_bugAddCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 579	fc, err := ec.fieldContext_Mutation_bugAddCommentAndClose(ctx, field)
 580	if err != nil {
 581		return graphql.Null
 582	}
 583	ctx = graphql.WithFieldContext(ctx, fc)
 584	defer func() {
 585		if r := recover(); r != nil {
 586			ec.Error(ctx, ec.Recover(ctx, r))
 587			ret = graphql.Null
 588		}
 589	}()
 590	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 591		ctx = rctx // use context from middleware stack in children
 592		return ec.resolvers.Mutation().BugAddCommentAndClose(rctx, fc.Args["input"].(models.BugAddCommentAndCloseInput))
 593	})
 594	if err != nil {
 595		ec.Error(ctx, err)
 596		return graphql.Null
 597	}
 598	if resTmp == nil {
 599		if !graphql.HasFieldError(ctx, fc) {
 600			ec.Errorf(ctx, "must not be null")
 601		}
 602		return graphql.Null
 603	}
 604	res := resTmp.(*models.BugAddCommentAndClosePayload)
 605	fc.Result = res
 606	return ec.marshalNBugAddCommentAndClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndClosePayload(ctx, field.Selections, res)
 607}
 608
 609func (ec *executionContext) fieldContext_Mutation_bugAddCommentAndClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 610	fc = &graphql.FieldContext{
 611		Object:     "Mutation",
 612		Field:      field,
 613		IsMethod:   true,
 614		IsResolver: true,
 615		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 616			switch field.Name {
 617			case "clientMutationId":
 618				return ec.fieldContext_BugAddCommentAndClosePayload_clientMutationId(ctx, field)
 619			case "bug":
 620				return ec.fieldContext_BugAddCommentAndClosePayload_bug(ctx, field)
 621			case "commentOperation":
 622				return ec.fieldContext_BugAddCommentAndClosePayload_commentOperation(ctx, field)
 623			case "statusOperation":
 624				return ec.fieldContext_BugAddCommentAndClosePayload_statusOperation(ctx, field)
 625			}
 626			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentAndClosePayload", field.Name)
 627		},
 628	}
 629	defer func() {
 630		if r := recover(); r != nil {
 631			err = ec.Recover(ctx, r)
 632			ec.Error(ctx, err)
 633		}
 634	}()
 635	ctx = graphql.WithFieldContext(ctx, fc)
 636	if fc.Args, err = ec.field_Mutation_bugAddCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 637		ec.Error(ctx, err)
 638		return fc, err
 639	}
 640	return fc, nil
 641}
 642
 643func (ec *executionContext) _Mutation_bugAddCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 644	fc, err := ec.fieldContext_Mutation_bugAddCommentAndReopen(ctx, field)
 645	if err != nil {
 646		return graphql.Null
 647	}
 648	ctx = graphql.WithFieldContext(ctx, fc)
 649	defer func() {
 650		if r := recover(); r != nil {
 651			ec.Error(ctx, ec.Recover(ctx, r))
 652			ret = graphql.Null
 653		}
 654	}()
 655	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 656		ctx = rctx // use context from middleware stack in children
 657		return ec.resolvers.Mutation().BugAddCommentAndReopen(rctx, fc.Args["input"].(models.BugAddCommentAndReopenInput))
 658	})
 659	if err != nil {
 660		ec.Error(ctx, err)
 661		return graphql.Null
 662	}
 663	if resTmp == nil {
 664		if !graphql.HasFieldError(ctx, fc) {
 665			ec.Errorf(ctx, "must not be null")
 666		}
 667		return graphql.Null
 668	}
 669	res := resTmp.(*models.BugAddCommentAndReopenPayload)
 670	fc.Result = res
 671	return ec.marshalNBugAddCommentAndReopenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenPayload(ctx, field.Selections, res)
 672}
 673
 674func (ec *executionContext) fieldContext_Mutation_bugAddCommentAndReopen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 675	fc = &graphql.FieldContext{
 676		Object:     "Mutation",
 677		Field:      field,
 678		IsMethod:   true,
 679		IsResolver: true,
 680		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 681			switch field.Name {
 682			case "clientMutationId":
 683				return ec.fieldContext_BugAddCommentAndReopenPayload_clientMutationId(ctx, field)
 684			case "bug":
 685				return ec.fieldContext_BugAddCommentAndReopenPayload_bug(ctx, field)
 686			case "commentOperation":
 687				return ec.fieldContext_BugAddCommentAndReopenPayload_commentOperation(ctx, field)
 688			case "statusOperation":
 689				return ec.fieldContext_BugAddCommentAndReopenPayload_statusOperation(ctx, field)
 690			}
 691			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentAndReopenPayload", field.Name)
 692		},
 693	}
 694	defer func() {
 695		if r := recover(); r != nil {
 696			err = ec.Recover(ctx, r)
 697			ec.Error(ctx, err)
 698		}
 699	}()
 700	ctx = graphql.WithFieldContext(ctx, fc)
 701	if fc.Args, err = ec.field_Mutation_bugAddCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 702		ec.Error(ctx, err)
 703		return fc, err
 704	}
 705	return fc, nil
 706}
 707
 708func (ec *executionContext) _Mutation_bugEditComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 709	fc, err := ec.fieldContext_Mutation_bugEditComment(ctx, field)
 710	if err != nil {
 711		return graphql.Null
 712	}
 713	ctx = graphql.WithFieldContext(ctx, fc)
 714	defer func() {
 715		if r := recover(); r != nil {
 716			ec.Error(ctx, ec.Recover(ctx, r))
 717			ret = graphql.Null
 718		}
 719	}()
 720	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 721		ctx = rctx // use context from middleware stack in children
 722		return ec.resolvers.Mutation().BugEditComment(rctx, fc.Args["input"].(models.BugEditCommentInput))
 723	})
 724	if err != nil {
 725		ec.Error(ctx, err)
 726		return graphql.Null
 727	}
 728	if resTmp == nil {
 729		if !graphql.HasFieldError(ctx, fc) {
 730			ec.Errorf(ctx, "must not be null")
 731		}
 732		return graphql.Null
 733	}
 734	res := resTmp.(*models.BugEditCommentPayload)
 735	fc.Result = res
 736	return ec.marshalNBugEditCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentPayload(ctx, field.Selections, res)
 737}
 738
 739func (ec *executionContext) fieldContext_Mutation_bugEditComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 740	fc = &graphql.FieldContext{
 741		Object:     "Mutation",
 742		Field:      field,
 743		IsMethod:   true,
 744		IsResolver: true,
 745		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 746			switch field.Name {
 747			case "clientMutationId":
 748				return ec.fieldContext_BugEditCommentPayload_clientMutationId(ctx, field)
 749			case "bug":
 750				return ec.fieldContext_BugEditCommentPayload_bug(ctx, field)
 751			case "operation":
 752				return ec.fieldContext_BugEditCommentPayload_operation(ctx, field)
 753			}
 754			return nil, fmt.Errorf("no field named %q was found under type BugEditCommentPayload", field.Name)
 755		},
 756	}
 757	defer func() {
 758		if r := recover(); r != nil {
 759			err = ec.Recover(ctx, r)
 760			ec.Error(ctx, err)
 761		}
 762	}()
 763	ctx = graphql.WithFieldContext(ctx, fc)
 764	if fc.Args, err = ec.field_Mutation_bugEditComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 765		ec.Error(ctx, err)
 766		return fc, err
 767	}
 768	return fc, nil
 769}
 770
 771func (ec *executionContext) _Mutation_bugChangeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 772	fc, err := ec.fieldContext_Mutation_bugChangeLabels(ctx, field)
 773	if err != nil {
 774		return graphql.Null
 775	}
 776	ctx = graphql.WithFieldContext(ctx, fc)
 777	defer func() {
 778		if r := recover(); r != nil {
 779			ec.Error(ctx, ec.Recover(ctx, r))
 780			ret = graphql.Null
 781		}
 782	}()
 783	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 784		ctx = rctx // use context from middleware stack in children
 785		return ec.resolvers.Mutation().BugChangeLabels(rctx, fc.Args["input"].(*models.BugChangeLabelInput))
 786	})
 787	if err != nil {
 788		ec.Error(ctx, err)
 789		return graphql.Null
 790	}
 791	if resTmp == nil {
 792		if !graphql.HasFieldError(ctx, fc) {
 793			ec.Errorf(ctx, "must not be null")
 794		}
 795		return graphql.Null
 796	}
 797	res := resTmp.(*models.BugChangeLabelPayload)
 798	fc.Result = res
 799	return ec.marshalNBugChangeLabelPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelPayload(ctx, field.Selections, res)
 800}
 801
 802func (ec *executionContext) fieldContext_Mutation_bugChangeLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 803	fc = &graphql.FieldContext{
 804		Object:     "Mutation",
 805		Field:      field,
 806		IsMethod:   true,
 807		IsResolver: true,
 808		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 809			switch field.Name {
 810			case "clientMutationId":
 811				return ec.fieldContext_BugChangeLabelPayload_clientMutationId(ctx, field)
 812			case "bug":
 813				return ec.fieldContext_BugChangeLabelPayload_bug(ctx, field)
 814			case "operation":
 815				return ec.fieldContext_BugChangeLabelPayload_operation(ctx, field)
 816			case "results":
 817				return ec.fieldContext_BugChangeLabelPayload_results(ctx, field)
 818			}
 819			return nil, fmt.Errorf("no field named %q was found under type BugChangeLabelPayload", field.Name)
 820		},
 821	}
 822	defer func() {
 823		if r := recover(); r != nil {
 824			err = ec.Recover(ctx, r)
 825			ec.Error(ctx, err)
 826		}
 827	}()
 828	ctx = graphql.WithFieldContext(ctx, fc)
 829	if fc.Args, err = ec.field_Mutation_bugChangeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 830		ec.Error(ctx, err)
 831		return fc, err
 832	}
 833	return fc, nil
 834}
 835
 836func (ec *executionContext) _Mutation_bugStatusOpen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 837	fc, err := ec.fieldContext_Mutation_bugStatusOpen(ctx, field)
 838	if err != nil {
 839		return graphql.Null
 840	}
 841	ctx = graphql.WithFieldContext(ctx, fc)
 842	defer func() {
 843		if r := recover(); r != nil {
 844			ec.Error(ctx, ec.Recover(ctx, r))
 845			ret = graphql.Null
 846		}
 847	}()
 848	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 849		ctx = rctx // use context from middleware stack in children
 850		return ec.resolvers.Mutation().BugStatusOpen(rctx, fc.Args["input"].(models.BugStatusOpenInput))
 851	})
 852	if err != nil {
 853		ec.Error(ctx, err)
 854		return graphql.Null
 855	}
 856	if resTmp == nil {
 857		if !graphql.HasFieldError(ctx, fc) {
 858			ec.Errorf(ctx, "must not be null")
 859		}
 860		return graphql.Null
 861	}
 862	res := resTmp.(*models.BugStatusOpenPayload)
 863	fc.Result = res
 864	return ec.marshalNBugStatusOpenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenPayload(ctx, field.Selections, res)
 865}
 866
 867func (ec *executionContext) fieldContext_Mutation_bugStatusOpen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 868	fc = &graphql.FieldContext{
 869		Object:     "Mutation",
 870		Field:      field,
 871		IsMethod:   true,
 872		IsResolver: true,
 873		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 874			switch field.Name {
 875			case "clientMutationId":
 876				return ec.fieldContext_BugStatusOpenPayload_clientMutationId(ctx, field)
 877			case "bug":
 878				return ec.fieldContext_BugStatusOpenPayload_bug(ctx, field)
 879			case "operation":
 880				return ec.fieldContext_BugStatusOpenPayload_operation(ctx, field)
 881			}
 882			return nil, fmt.Errorf("no field named %q was found under type BugStatusOpenPayload", field.Name)
 883		},
 884	}
 885	defer func() {
 886		if r := recover(); r != nil {
 887			err = ec.Recover(ctx, r)
 888			ec.Error(ctx, err)
 889		}
 890	}()
 891	ctx = graphql.WithFieldContext(ctx, fc)
 892	if fc.Args, err = ec.field_Mutation_bugStatusOpen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 893		ec.Error(ctx, err)
 894		return fc, err
 895	}
 896	return fc, nil
 897}
 898
 899func (ec *executionContext) _Mutation_bugStatusClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 900	fc, err := ec.fieldContext_Mutation_bugStatusClose(ctx, field)
 901	if err != nil {
 902		return graphql.Null
 903	}
 904	ctx = graphql.WithFieldContext(ctx, fc)
 905	defer func() {
 906		if r := recover(); r != nil {
 907			ec.Error(ctx, ec.Recover(ctx, r))
 908			ret = graphql.Null
 909		}
 910	}()
 911	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 912		ctx = rctx // use context from middleware stack in children
 913		return ec.resolvers.Mutation().BugStatusClose(rctx, fc.Args["input"].(models.BugStatusCloseInput))
 914	})
 915	if err != nil {
 916		ec.Error(ctx, err)
 917		return graphql.Null
 918	}
 919	if resTmp == nil {
 920		if !graphql.HasFieldError(ctx, fc) {
 921			ec.Errorf(ctx, "must not be null")
 922		}
 923		return graphql.Null
 924	}
 925	res := resTmp.(*models.BugStatusClosePayload)
 926	fc.Result = res
 927	return ec.marshalNBugStatusClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusClosePayload(ctx, field.Selections, res)
 928}
 929
 930func (ec *executionContext) fieldContext_Mutation_bugStatusClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 931	fc = &graphql.FieldContext{
 932		Object:     "Mutation",
 933		Field:      field,
 934		IsMethod:   true,
 935		IsResolver: true,
 936		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 937			switch field.Name {
 938			case "clientMutationId":
 939				return ec.fieldContext_BugStatusClosePayload_clientMutationId(ctx, field)
 940			case "bug":
 941				return ec.fieldContext_BugStatusClosePayload_bug(ctx, field)
 942			case "operation":
 943				return ec.fieldContext_BugStatusClosePayload_operation(ctx, field)
 944			}
 945			return nil, fmt.Errorf("no field named %q was found under type BugStatusClosePayload", field.Name)
 946		},
 947	}
 948	defer func() {
 949		if r := recover(); r != nil {
 950			err = ec.Recover(ctx, r)
 951			ec.Error(ctx, err)
 952		}
 953	}()
 954	ctx = graphql.WithFieldContext(ctx, fc)
 955	if fc.Args, err = ec.field_Mutation_bugStatusClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 956		ec.Error(ctx, err)
 957		return fc, err
 958	}
 959	return fc, nil
 960}
 961
 962func (ec *executionContext) _Mutation_bugSetTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 963	fc, err := ec.fieldContext_Mutation_bugSetTitle(ctx, field)
 964	if err != nil {
 965		return graphql.Null
 966	}
 967	ctx = graphql.WithFieldContext(ctx, fc)
 968	defer func() {
 969		if r := recover(); r != nil {
 970			ec.Error(ctx, ec.Recover(ctx, r))
 971			ret = graphql.Null
 972		}
 973	}()
 974	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 975		ctx = rctx // use context from middleware stack in children
 976		return ec.resolvers.Mutation().BugSetTitle(rctx, fc.Args["input"].(models.BugSetTitleInput))
 977	})
 978	if err != nil {
 979		ec.Error(ctx, err)
 980		return graphql.Null
 981	}
 982	if resTmp == nil {
 983		if !graphql.HasFieldError(ctx, fc) {
 984			ec.Errorf(ctx, "must not be null")
 985		}
 986		return graphql.Null
 987	}
 988	res := resTmp.(*models.BugSetTitlePayload)
 989	fc.Result = res
 990	return ec.marshalNBugSetTitlePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitlePayload(ctx, field.Selections, res)
 991}
 992
 993func (ec *executionContext) fieldContext_Mutation_bugSetTitle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 994	fc = &graphql.FieldContext{
 995		Object:     "Mutation",
 996		Field:      field,
 997		IsMethod:   true,
 998		IsResolver: true,
 999		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1000			switch field.Name {
1001			case "clientMutationId":
1002				return ec.fieldContext_BugSetTitlePayload_clientMutationId(ctx, field)
1003			case "bug":
1004				return ec.fieldContext_BugSetTitlePayload_bug(ctx, field)
1005			case "operation":
1006				return ec.fieldContext_BugSetTitlePayload_operation(ctx, field)
1007			}
1008			return nil, fmt.Errorf("no field named %q was found under type BugSetTitlePayload", field.Name)
1009		},
1010	}
1011	defer func() {
1012		if r := recover(); r != nil {
1013			err = ec.Recover(ctx, r)
1014			ec.Error(ctx, err)
1015		}
1016	}()
1017	ctx = graphql.WithFieldContext(ctx, fc)
1018	if fc.Args, err = ec.field_Mutation_bugSetTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1019		ec.Error(ctx, err)
1020		return fc, err
1021	}
1022	return fc, nil
1023}
1024
1025func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
1026	fc, err := ec.fieldContext_Query_repository(ctx, field)
1027	if err != nil {
1028		return graphql.Null
1029	}
1030	ctx = graphql.WithFieldContext(ctx, fc)
1031	defer func() {
1032		if r := recover(); r != nil {
1033			ec.Error(ctx, ec.Recover(ctx, r))
1034			ret = graphql.Null
1035		}
1036	}()
1037	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1038		ctx = rctx // use context from middleware stack in children
1039		return ec.resolvers.Query().Repository(rctx, fc.Args["ref"].(*string))
1040	})
1041	if err != nil {
1042		ec.Error(ctx, err)
1043		return graphql.Null
1044	}
1045	if resTmp == nil {
1046		return graphql.Null
1047	}
1048	res := resTmp.(*models.Repository)
1049	fc.Result = res
1050	return ec.marshalORepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
1051}
1052
1053func (ec *executionContext) fieldContext_Query_repository(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1054	fc = &graphql.FieldContext{
1055		Object:     "Query",
1056		Field:      field,
1057		IsMethod:   true,
1058		IsResolver: true,
1059		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1060			switch field.Name {
1061			case "name":
1062				return ec.fieldContext_Repository_name(ctx, field)
1063			case "allBugs":
1064				return ec.fieldContext_Repository_allBugs(ctx, field)
1065			case "bug":
1066				return ec.fieldContext_Repository_bug(ctx, field)
1067			case "allIdentities":
1068				return ec.fieldContext_Repository_allIdentities(ctx, field)
1069			case "identity":
1070				return ec.fieldContext_Repository_identity(ctx, field)
1071			case "userIdentity":
1072				return ec.fieldContext_Repository_userIdentity(ctx, field)
1073			case "validLabels":
1074				return ec.fieldContext_Repository_validLabels(ctx, field)
1075			}
1076			return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
1077		},
1078	}
1079	defer func() {
1080		if r := recover(); r != nil {
1081			err = ec.Recover(ctx, r)
1082			ec.Error(ctx, err)
1083		}
1084	}()
1085	ctx = graphql.WithFieldContext(ctx, fc)
1086	if fc.Args, err = ec.field_Query_repository_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1087		ec.Error(ctx, err)
1088		return fc, err
1089	}
1090	return fc, nil
1091}
1092
1093func (ec *executionContext) _Query_repositories(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
1094	fc, err := ec.fieldContext_Query_repositories(ctx, field)
1095	if err != nil {
1096		return graphql.Null
1097	}
1098	ctx = graphql.WithFieldContext(ctx, fc)
1099	defer func() {
1100		if r := recover(); r != nil {
1101			ec.Error(ctx, ec.Recover(ctx, r))
1102			ret = graphql.Null
1103		}
1104	}()
1105	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1106		ctx = rctx // use context from middleware stack in children
1107		return ec.resolvers.Query().Repositories(rctx, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1108	})
1109	if err != nil {
1110		ec.Error(ctx, err)
1111		return graphql.Null
1112	}
1113	if resTmp == nil {
1114		if !graphql.HasFieldError(ctx, fc) {
1115			ec.Errorf(ctx, "must not be null")
1116		}
1117		return graphql.Null
1118	}
1119	res := resTmp.(*models.RepositoryConnection)
1120	fc.Result = res
1121	return ec.marshalNRepositoryConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryConnection(ctx, field.Selections, res)
1122}
1123
1124func (ec *executionContext) fieldContext_Query_repositories(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1125	fc = &graphql.FieldContext{
1126		Object:     "Query",
1127		Field:      field,
1128		IsMethod:   true,
1129		IsResolver: true,
1130		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1131			switch field.Name {
1132			case "edges":
1133				return ec.fieldContext_RepositoryConnection_edges(ctx, field)
1134			case "nodes":
1135				return ec.fieldContext_RepositoryConnection_nodes(ctx, field)
1136			case "pageInfo":
1137				return ec.fieldContext_RepositoryConnection_pageInfo(ctx, field)
1138			case "totalCount":
1139				return ec.fieldContext_RepositoryConnection_totalCount(ctx, field)
1140			}
1141			return nil, fmt.Errorf("no field named %q was found under type RepositoryConnection", field.Name)
1142		},
1143	}
1144	defer func() {
1145		if r := recover(); r != nil {
1146			err = ec.Recover(ctx, r)
1147			ec.Error(ctx, err)
1148		}
1149	}()
1150	ctx = graphql.WithFieldContext(ctx, fc)
1151	if fc.Args, err = ec.field_Query_repositories_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1152		ec.Error(ctx, err)
1153		return fc, err
1154	}
1155	return fc, nil
1156}
1157
1158func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
1159	fc, err := ec.fieldContext_Query___type(ctx, field)
1160	if err != nil {
1161		return graphql.Null
1162	}
1163	ctx = graphql.WithFieldContext(ctx, fc)
1164	defer func() {
1165		if r := recover(); r != nil {
1166			ec.Error(ctx, ec.Recover(ctx, r))
1167			ret = graphql.Null
1168		}
1169	}()
1170	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1171		ctx = rctx // use context from middleware stack in children
1172		return ec.introspectType(fc.Args["name"].(string))
1173	})
1174	if err != nil {
1175		ec.Error(ctx, err)
1176		return graphql.Null
1177	}
1178	if resTmp == nil {
1179		return graphql.Null
1180	}
1181	res := resTmp.(*introspection.Type)
1182	fc.Result = res
1183	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1184}
1185
1186func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1187	fc = &graphql.FieldContext{
1188		Object:     "Query",
1189		Field:      field,
1190		IsMethod:   true,
1191		IsResolver: false,
1192		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1193			switch field.Name {
1194			case "kind":
1195				return ec.fieldContext___Type_kind(ctx, field)
1196			case "name":
1197				return ec.fieldContext___Type_name(ctx, field)
1198			case "description":
1199				return ec.fieldContext___Type_description(ctx, field)
1200			case "specifiedByURL":
1201				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1202			case "fields":
1203				return ec.fieldContext___Type_fields(ctx, field)
1204			case "interfaces":
1205				return ec.fieldContext___Type_interfaces(ctx, field)
1206			case "possibleTypes":
1207				return ec.fieldContext___Type_possibleTypes(ctx, field)
1208			case "enumValues":
1209				return ec.fieldContext___Type_enumValues(ctx, field)
1210			case "inputFields":
1211				return ec.fieldContext___Type_inputFields(ctx, field)
1212			case "ofType":
1213				return ec.fieldContext___Type_ofType(ctx, field)
1214			case "isOneOf":
1215				return ec.fieldContext___Type_isOneOf(ctx, field)
1216			}
1217			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1218		},
1219	}
1220	defer func() {
1221		if r := recover(); r != nil {
1222			err = ec.Recover(ctx, r)
1223			ec.Error(ctx, err)
1224		}
1225	}()
1226	ctx = graphql.WithFieldContext(ctx, fc)
1227	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1228		ec.Error(ctx, err)
1229		return fc, err
1230	}
1231	return fc, nil
1232}
1233
1234func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
1235	fc, err := ec.fieldContext_Query___schema(ctx, field)
1236	if err != nil {
1237		return graphql.Null
1238	}
1239	ctx = graphql.WithFieldContext(ctx, fc)
1240	defer func() {
1241		if r := recover(); r != nil {
1242			ec.Error(ctx, ec.Recover(ctx, r))
1243			ret = graphql.Null
1244		}
1245	}()
1246	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1247		ctx = rctx // use context from middleware stack in children
1248		return ec.introspectSchema()
1249	})
1250	if err != nil {
1251		ec.Error(ctx, err)
1252		return graphql.Null
1253	}
1254	if resTmp == nil {
1255		return graphql.Null
1256	}
1257	res := resTmp.(*introspection.Schema)
1258	fc.Result = res
1259	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
1260}
1261
1262func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1263	fc = &graphql.FieldContext{
1264		Object:     "Query",
1265		Field:      field,
1266		IsMethod:   true,
1267		IsResolver: false,
1268		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1269			switch field.Name {
1270			case "description":
1271				return ec.fieldContext___Schema_description(ctx, field)
1272			case "types":
1273				return ec.fieldContext___Schema_types(ctx, field)
1274			case "queryType":
1275				return ec.fieldContext___Schema_queryType(ctx, field)
1276			case "mutationType":
1277				return ec.fieldContext___Schema_mutationType(ctx, field)
1278			case "subscriptionType":
1279				return ec.fieldContext___Schema_subscriptionType(ctx, field)
1280			case "directives":
1281				return ec.fieldContext___Schema_directives(ctx, field)
1282			}
1283			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
1284		},
1285	}
1286	return fc, nil
1287}
1288
1289// endregion **************************** field.gotpl *****************************
1290
1291// region    **************************** input.gotpl *****************************
1292
1293// endregion **************************** input.gotpl *****************************
1294
1295// region    ************************** interface.gotpl ***************************
1296
1297// endregion ************************** interface.gotpl ***************************
1298
1299// region    **************************** object.gotpl ****************************
1300
1301var mutationImplementors = []string{"Mutation"}
1302
1303func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
1304	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
1305	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
1306		Object: "Mutation",
1307	})
1308
1309	out := graphql.NewFieldSet(fields)
1310	deferred := make(map[string]*graphql.FieldSet)
1311	for i, field := range fields {
1312		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
1313			Object: field.Name,
1314			Field:  field,
1315		})
1316
1317		switch field.Name {
1318		case "__typename":
1319			out.Values[i] = graphql.MarshalString("Mutation")
1320		case "bugCreate":
1321			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1322				return ec._Mutation_bugCreate(ctx, field)
1323			})
1324			if out.Values[i] == graphql.Null {
1325				out.Invalids++
1326			}
1327		case "bugAddComment":
1328			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1329				return ec._Mutation_bugAddComment(ctx, field)
1330			})
1331			if out.Values[i] == graphql.Null {
1332				out.Invalids++
1333			}
1334		case "bugAddCommentAndClose":
1335			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1336				return ec._Mutation_bugAddCommentAndClose(ctx, field)
1337			})
1338			if out.Values[i] == graphql.Null {
1339				out.Invalids++
1340			}
1341		case "bugAddCommentAndReopen":
1342			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1343				return ec._Mutation_bugAddCommentAndReopen(ctx, field)
1344			})
1345			if out.Values[i] == graphql.Null {
1346				out.Invalids++
1347			}
1348		case "bugEditComment":
1349			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1350				return ec._Mutation_bugEditComment(ctx, field)
1351			})
1352			if out.Values[i] == graphql.Null {
1353				out.Invalids++
1354			}
1355		case "bugChangeLabels":
1356			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1357				return ec._Mutation_bugChangeLabels(ctx, field)
1358			})
1359			if out.Values[i] == graphql.Null {
1360				out.Invalids++
1361			}
1362		case "bugStatusOpen":
1363			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1364				return ec._Mutation_bugStatusOpen(ctx, field)
1365			})
1366			if out.Values[i] == graphql.Null {
1367				out.Invalids++
1368			}
1369		case "bugStatusClose":
1370			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1371				return ec._Mutation_bugStatusClose(ctx, field)
1372			})
1373			if out.Values[i] == graphql.Null {
1374				out.Invalids++
1375			}
1376		case "bugSetTitle":
1377			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1378				return ec._Mutation_bugSetTitle(ctx, field)
1379			})
1380			if out.Values[i] == graphql.Null {
1381				out.Invalids++
1382			}
1383		default:
1384			panic("unknown field " + strconv.Quote(field.Name))
1385		}
1386	}
1387	out.Dispatch(ctx)
1388	if out.Invalids > 0 {
1389		return graphql.Null
1390	}
1391
1392	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1393
1394	for label, dfs := range deferred {
1395		ec.processDeferredGroup(graphql.DeferredGroup{
1396			Label:    label,
1397			Path:     graphql.GetPath(ctx),
1398			FieldSet: dfs,
1399			Context:  ctx,
1400		})
1401	}
1402
1403	return out
1404}
1405
1406var queryImplementors = []string{"Query"}
1407
1408func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
1409	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
1410	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
1411		Object: "Query",
1412	})
1413
1414	out := graphql.NewFieldSet(fields)
1415	deferred := make(map[string]*graphql.FieldSet)
1416	for i, field := range fields {
1417		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
1418			Object: field.Name,
1419			Field:  field,
1420		})
1421
1422		switch field.Name {
1423		case "__typename":
1424			out.Values[i] = graphql.MarshalString("Query")
1425		case "repository":
1426			field := field
1427
1428			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1429				defer func() {
1430					if r := recover(); r != nil {
1431						ec.Error(ctx, ec.Recover(ctx, r))
1432					}
1433				}()
1434				res = ec._Query_repository(ctx, field)
1435				return res
1436			}
1437
1438			rrm := func(ctx context.Context) graphql.Marshaler {
1439				return ec.OperationContext.RootResolverMiddleware(ctx,
1440					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1441			}
1442
1443			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
1444		case "repositories":
1445			field := field
1446
1447			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1448				defer func() {
1449					if r := recover(); r != nil {
1450						ec.Error(ctx, ec.Recover(ctx, r))
1451					}
1452				}()
1453				res = ec._Query_repositories(ctx, field)
1454				if res == graphql.Null {
1455					atomic.AddUint32(&fs.Invalids, 1)
1456				}
1457				return res
1458			}
1459
1460			rrm := func(ctx context.Context) graphql.Marshaler {
1461				return ec.OperationContext.RootResolverMiddleware(ctx,
1462					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1463			}
1464
1465			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
1466		case "__type":
1467			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1468				return ec._Query___type(ctx, field)
1469			})
1470		case "__schema":
1471			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
1472				return ec._Query___schema(ctx, field)
1473			})
1474		default:
1475			panic("unknown field " + strconv.Quote(field.Name))
1476		}
1477	}
1478	out.Dispatch(ctx)
1479	if out.Invalids > 0 {
1480		return graphql.Null
1481	}
1482
1483	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1484
1485	for label, dfs := range deferred {
1486		ec.processDeferredGroup(graphql.DeferredGroup{
1487			Label:    label,
1488			Path:     graphql.GetPath(ctx),
1489			FieldSet: dfs,
1490			Context:  ctx,
1491		})
1492	}
1493
1494	return out
1495}
1496
1497// endregion **************************** object.gotpl ****************************
1498
1499// region    ***************************** type.gotpl *****************************
1500
1501// endregion ***************************** type.gotpl *****************************