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