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