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"
  11	"sync/atomic"
  12	"time"
  13
  14	"github.com/99designs/gqlgen/graphql"
  15	"github.com/git-bug/git-bug/api/graphql/models"
  16	"github.com/git-bug/git-bug/repository"
  17	"github.com/vektah/gqlparser/v2/ast"
  18)
  19
  20// region    ************************** generated!.gotpl **************************
  21
  22type GitCommitResolver interface {
  23	ShortHash(ctx context.Context, obj *models.GitCommitMeta) (string, error)
  24
  25	FullMessage(ctx context.Context, obj *models.GitCommitMeta) (string, error)
  26
  27	Parents(ctx context.Context, obj *models.GitCommitMeta) ([]string, error)
  28	Files(ctx context.Context, obj *models.GitCommitMeta, after *string, before *string, first *int, last *int) (*models.GitChangedFileConnection, error)
  29	Diff(ctx context.Context, obj *models.GitCommitMeta, path string) (*repository.FileDiff, error)
  30}
  31type GitRefResolver interface {
  32	Commit(ctx context.Context, obj *models.GitRef) (*models.GitCommitMeta, error)
  33}
  34type GitTreeEntryResolver interface {
  35	LastCommit(ctx context.Context, obj *models.GitTreeEntry) (*models.GitCommitMeta, error)
  36}
  37
  38// endregion ************************** generated!.gotpl **************************
  39
  40// region    ***************************** args.gotpl *****************************
  41
  42func (ec *executionContext) field_GitCommit_diff_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  43	var err error
  44	args := map[string]any{}
  45	arg0, err := ec.field_GitCommit_diff_argsPath(ctx, rawArgs)
  46	if err != nil {
  47		return nil, err
  48	}
  49	args["path"] = arg0
  50	return args, nil
  51}
  52func (ec *executionContext) field_GitCommit_diff_argsPath(
  53	ctx context.Context,
  54	rawArgs map[string]any,
  55) (string, error) {
  56	if _, ok := rawArgs["path"]; !ok {
  57		var zeroVal string
  58		return zeroVal, nil
  59	}
  60
  61	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))
  62	if tmp, ok := rawArgs["path"]; ok {
  63		return ec.unmarshalNString2string(ctx, tmp)
  64	}
  65
  66	var zeroVal string
  67	return zeroVal, nil
  68}
  69
  70func (ec *executionContext) field_GitCommit_files_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  71	var err error
  72	args := map[string]any{}
  73	arg0, err := ec.field_GitCommit_files_argsAfter(ctx, rawArgs)
  74	if err != nil {
  75		return nil, err
  76	}
  77	args["after"] = arg0
  78	arg1, err := ec.field_GitCommit_files_argsBefore(ctx, rawArgs)
  79	if err != nil {
  80		return nil, err
  81	}
  82	args["before"] = arg1
  83	arg2, err := ec.field_GitCommit_files_argsFirst(ctx, rawArgs)
  84	if err != nil {
  85		return nil, err
  86	}
  87	args["first"] = arg2
  88	arg3, err := ec.field_GitCommit_files_argsLast(ctx, rawArgs)
  89	if err != nil {
  90		return nil, err
  91	}
  92	args["last"] = arg3
  93	return args, nil
  94}
  95func (ec *executionContext) field_GitCommit_files_argsAfter(
  96	ctx context.Context,
  97	rawArgs map[string]any,
  98) (*string, error) {
  99	if _, ok := rawArgs["after"]; !ok {
 100		var zeroVal *string
 101		return zeroVal, nil
 102	}
 103
 104	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 105	if tmp, ok := rawArgs["after"]; ok {
 106		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 107	}
 108
 109	var zeroVal *string
 110	return zeroVal, nil
 111}
 112
 113func (ec *executionContext) field_GitCommit_files_argsBefore(
 114	ctx context.Context,
 115	rawArgs map[string]any,
 116) (*string, error) {
 117	if _, ok := rawArgs["before"]; !ok {
 118		var zeroVal *string
 119		return zeroVal, nil
 120	}
 121
 122	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 123	if tmp, ok := rawArgs["before"]; ok {
 124		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 125	}
 126
 127	var zeroVal *string
 128	return zeroVal, nil
 129}
 130
 131func (ec *executionContext) field_GitCommit_files_argsFirst(
 132	ctx context.Context,
 133	rawArgs map[string]any,
 134) (*int, error) {
 135	if _, ok := rawArgs["first"]; !ok {
 136		var zeroVal *int
 137		return zeroVal, nil
 138	}
 139
 140	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 141	if tmp, ok := rawArgs["first"]; ok {
 142		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 143	}
 144
 145	var zeroVal *int
 146	return zeroVal, nil
 147}
 148
 149func (ec *executionContext) field_GitCommit_files_argsLast(
 150	ctx context.Context,
 151	rawArgs map[string]any,
 152) (*int, error) {
 153	if _, ok := rawArgs["last"]; !ok {
 154		var zeroVal *int
 155		return zeroVal, nil
 156	}
 157
 158	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 159	if tmp, ok := rawArgs["last"]; ok {
 160		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 161	}
 162
 163	var zeroVal *int
 164	return zeroVal, nil
 165}
 166
 167// endregion ***************************** args.gotpl *****************************
 168
 169// region    ************************** directives.gotpl **************************
 170
 171// endregion ************************** directives.gotpl **************************
 172
 173// region    **************************** field.gotpl *****************************
 174
 175func (ec *executionContext) _GitBlob_path(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 176	fc, err := ec.fieldContext_GitBlob_path(ctx, field)
 177	if err != nil {
 178		return graphql.Null
 179	}
 180	ctx = graphql.WithFieldContext(ctx, fc)
 181	defer func() {
 182		if r := recover(); r != nil {
 183			ec.Error(ctx, ec.Recover(ctx, r))
 184			ret = graphql.Null
 185		}
 186	}()
 187	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 188		ctx = rctx // use context from middleware stack in children
 189		return obj.Path, nil
 190	})
 191	if err != nil {
 192		ec.Error(ctx, err)
 193		return graphql.Null
 194	}
 195	if resTmp == nil {
 196		if !graphql.HasFieldError(ctx, fc) {
 197			ec.Errorf(ctx, "must not be null")
 198		}
 199		return graphql.Null
 200	}
 201	res := resTmp.(string)
 202	fc.Result = res
 203	return ec.marshalNString2string(ctx, field.Selections, res)
 204}
 205
 206func (ec *executionContext) fieldContext_GitBlob_path(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 207	fc = &graphql.FieldContext{
 208		Object:     "GitBlob",
 209		Field:      field,
 210		IsMethod:   false,
 211		IsResolver: false,
 212		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 213			return nil, errors.New("field of type String does not have child fields")
 214		},
 215	}
 216	return fc, nil
 217}
 218
 219func (ec *executionContext) _GitBlob_hash(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 220	fc, err := ec.fieldContext_GitBlob_hash(ctx, field)
 221	if err != nil {
 222		return graphql.Null
 223	}
 224	ctx = graphql.WithFieldContext(ctx, fc)
 225	defer func() {
 226		if r := recover(); r != nil {
 227			ec.Error(ctx, ec.Recover(ctx, r))
 228			ret = graphql.Null
 229		}
 230	}()
 231	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 232		ctx = rctx // use context from middleware stack in children
 233		return obj.Hash, nil
 234	})
 235	if err != nil {
 236		ec.Error(ctx, err)
 237		return graphql.Null
 238	}
 239	if resTmp == nil {
 240		if !graphql.HasFieldError(ctx, fc) {
 241			ec.Errorf(ctx, "must not be null")
 242		}
 243		return graphql.Null
 244	}
 245	res := resTmp.(string)
 246	fc.Result = res
 247	return ec.marshalNString2string(ctx, field.Selections, res)
 248}
 249
 250func (ec *executionContext) fieldContext_GitBlob_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 251	fc = &graphql.FieldContext{
 252		Object:     "GitBlob",
 253		Field:      field,
 254		IsMethod:   false,
 255		IsResolver: false,
 256		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 257			return nil, errors.New("field of type String does not have child fields")
 258		},
 259	}
 260	return fc, nil
 261}
 262
 263func (ec *executionContext) _GitBlob_text(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 264	fc, err := ec.fieldContext_GitBlob_text(ctx, field)
 265	if err != nil {
 266		return graphql.Null
 267	}
 268	ctx = graphql.WithFieldContext(ctx, fc)
 269	defer func() {
 270		if r := recover(); r != nil {
 271			ec.Error(ctx, ec.Recover(ctx, r))
 272			ret = graphql.Null
 273		}
 274	}()
 275	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 276		ctx = rctx // use context from middleware stack in children
 277		return obj.Text, nil
 278	})
 279	if err != nil {
 280		ec.Error(ctx, err)
 281		return graphql.Null
 282	}
 283	if resTmp == nil {
 284		return graphql.Null
 285	}
 286	res := resTmp.(*string)
 287	fc.Result = res
 288	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 289}
 290
 291func (ec *executionContext) fieldContext_GitBlob_text(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 292	fc = &graphql.FieldContext{
 293		Object:     "GitBlob",
 294		Field:      field,
 295		IsMethod:   false,
 296		IsResolver: false,
 297		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 298			return nil, errors.New("field of type String does not have child fields")
 299		},
 300	}
 301	return fc, nil
 302}
 303
 304func (ec *executionContext) _GitBlob_size(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 305	fc, err := ec.fieldContext_GitBlob_size(ctx, field)
 306	if err != nil {
 307		return graphql.Null
 308	}
 309	ctx = graphql.WithFieldContext(ctx, fc)
 310	defer func() {
 311		if r := recover(); r != nil {
 312			ec.Error(ctx, ec.Recover(ctx, r))
 313			ret = graphql.Null
 314		}
 315	}()
 316	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 317		ctx = rctx // use context from middleware stack in children
 318		return obj.Size, nil
 319	})
 320	if err != nil {
 321		ec.Error(ctx, err)
 322		return graphql.Null
 323	}
 324	if resTmp == nil {
 325		if !graphql.HasFieldError(ctx, fc) {
 326			ec.Errorf(ctx, "must not be null")
 327		}
 328		return graphql.Null
 329	}
 330	res := resTmp.(int)
 331	fc.Result = res
 332	return ec.marshalNInt2int(ctx, field.Selections, res)
 333}
 334
 335func (ec *executionContext) fieldContext_GitBlob_size(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 336	fc = &graphql.FieldContext{
 337		Object:     "GitBlob",
 338		Field:      field,
 339		IsMethod:   false,
 340		IsResolver: false,
 341		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 342			return nil, errors.New("field of type Int does not have child fields")
 343		},
 344	}
 345	return fc, nil
 346}
 347
 348func (ec *executionContext) _GitBlob_isBinary(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 349	fc, err := ec.fieldContext_GitBlob_isBinary(ctx, field)
 350	if err != nil {
 351		return graphql.Null
 352	}
 353	ctx = graphql.WithFieldContext(ctx, fc)
 354	defer func() {
 355		if r := recover(); r != nil {
 356			ec.Error(ctx, ec.Recover(ctx, r))
 357			ret = graphql.Null
 358		}
 359	}()
 360	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 361		ctx = rctx // use context from middleware stack in children
 362		return obj.IsBinary, nil
 363	})
 364	if err != nil {
 365		ec.Error(ctx, err)
 366		return graphql.Null
 367	}
 368	if resTmp == nil {
 369		if !graphql.HasFieldError(ctx, fc) {
 370			ec.Errorf(ctx, "must not be null")
 371		}
 372		return graphql.Null
 373	}
 374	res := resTmp.(bool)
 375	fc.Result = res
 376	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 377}
 378
 379func (ec *executionContext) fieldContext_GitBlob_isBinary(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 380	fc = &graphql.FieldContext{
 381		Object:     "GitBlob",
 382		Field:      field,
 383		IsMethod:   false,
 384		IsResolver: false,
 385		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 386			return nil, errors.New("field of type Boolean does not have child fields")
 387		},
 388	}
 389	return fc, nil
 390}
 391
 392func (ec *executionContext) _GitBlob_isTruncated(ctx context.Context, field graphql.CollectedField, obj *models.GitBlob) (ret graphql.Marshaler) {
 393	fc, err := ec.fieldContext_GitBlob_isTruncated(ctx, field)
 394	if err != nil {
 395		return graphql.Null
 396	}
 397	ctx = graphql.WithFieldContext(ctx, fc)
 398	defer func() {
 399		if r := recover(); r != nil {
 400			ec.Error(ctx, ec.Recover(ctx, r))
 401			ret = graphql.Null
 402		}
 403	}()
 404	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 405		ctx = rctx // use context from middleware stack in children
 406		return obj.IsTruncated, nil
 407	})
 408	if err != nil {
 409		ec.Error(ctx, err)
 410		return graphql.Null
 411	}
 412	if resTmp == nil {
 413		if !graphql.HasFieldError(ctx, fc) {
 414			ec.Errorf(ctx, "must not be null")
 415		}
 416		return graphql.Null
 417	}
 418	res := resTmp.(bool)
 419	fc.Result = res
 420	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 421}
 422
 423func (ec *executionContext) fieldContext_GitBlob_isTruncated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 424	fc = &graphql.FieldContext{
 425		Object:     "GitBlob",
 426		Field:      field,
 427		IsMethod:   false,
 428		IsResolver: false,
 429		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 430			return nil, errors.New("field of type Boolean does not have child fields")
 431		},
 432	}
 433	return fc, nil
 434}
 435
 436func (ec *executionContext) _GitChangedFile_path(ctx context.Context, field graphql.CollectedField, obj *repository.ChangedFile) (ret graphql.Marshaler) {
 437	fc, err := ec.fieldContext_GitChangedFile_path(ctx, field)
 438	if err != nil {
 439		return graphql.Null
 440	}
 441	ctx = graphql.WithFieldContext(ctx, fc)
 442	defer func() {
 443		if r := recover(); r != nil {
 444			ec.Error(ctx, ec.Recover(ctx, r))
 445			ret = graphql.Null
 446		}
 447	}()
 448	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 449		ctx = rctx // use context from middleware stack in children
 450		return obj.Path, nil
 451	})
 452	if err != nil {
 453		ec.Error(ctx, err)
 454		return graphql.Null
 455	}
 456	if resTmp == nil {
 457		if !graphql.HasFieldError(ctx, fc) {
 458			ec.Errorf(ctx, "must not be null")
 459		}
 460		return graphql.Null
 461	}
 462	res := resTmp.(string)
 463	fc.Result = res
 464	return ec.marshalNString2string(ctx, field.Selections, res)
 465}
 466
 467func (ec *executionContext) fieldContext_GitChangedFile_path(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 468	fc = &graphql.FieldContext{
 469		Object:     "GitChangedFile",
 470		Field:      field,
 471		IsMethod:   false,
 472		IsResolver: false,
 473		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 474			return nil, errors.New("field of type String does not have child fields")
 475		},
 476	}
 477	return fc, nil
 478}
 479
 480func (ec *executionContext) _GitChangedFile_oldPath(ctx context.Context, field graphql.CollectedField, obj *repository.ChangedFile) (ret graphql.Marshaler) {
 481	fc, err := ec.fieldContext_GitChangedFile_oldPath(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 obj.OldPath, nil
 495	})
 496	if err != nil {
 497		ec.Error(ctx, err)
 498		return graphql.Null
 499	}
 500	if resTmp == nil {
 501		return graphql.Null
 502	}
 503	res := resTmp.(*string)
 504	fc.Result = res
 505	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 506}
 507
 508func (ec *executionContext) fieldContext_GitChangedFile_oldPath(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 509	fc = &graphql.FieldContext{
 510		Object:     "GitChangedFile",
 511		Field:      field,
 512		IsMethod:   false,
 513		IsResolver: false,
 514		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 515			return nil, errors.New("field of type String does not have child fields")
 516		},
 517	}
 518	return fc, nil
 519}
 520
 521func (ec *executionContext) _GitChangedFile_status(ctx context.Context, field graphql.CollectedField, obj *repository.ChangedFile) (ret graphql.Marshaler) {
 522	fc, err := ec.fieldContext_GitChangedFile_status(ctx, field)
 523	if err != nil {
 524		return graphql.Null
 525	}
 526	ctx = graphql.WithFieldContext(ctx, fc)
 527	defer func() {
 528		if r := recover(); r != nil {
 529			ec.Error(ctx, ec.Recover(ctx, r))
 530			ret = graphql.Null
 531		}
 532	}()
 533	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 534		ctx = rctx // use context from middleware stack in children
 535		return obj.Status, nil
 536	})
 537	if err != nil {
 538		ec.Error(ctx, err)
 539		return graphql.Null
 540	}
 541	if resTmp == nil {
 542		if !graphql.HasFieldError(ctx, fc) {
 543			ec.Errorf(ctx, "must not be null")
 544		}
 545		return graphql.Null
 546	}
 547	res := resTmp.(repository.ChangeStatus)
 548	fc.Result = res
 549	return ec.marshalNGitChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangeStatus(ctx, field.Selections, res)
 550}
 551
 552func (ec *executionContext) fieldContext_GitChangedFile_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 553	fc = &graphql.FieldContext{
 554		Object:     "GitChangedFile",
 555		Field:      field,
 556		IsMethod:   false,
 557		IsResolver: false,
 558		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 559			return nil, errors.New("field of type GitChangeStatus does not have child fields")
 560		},
 561	}
 562	return fc, nil
 563}
 564
 565func (ec *executionContext) _GitChangedFileConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.GitChangedFileConnection) (ret graphql.Marshaler) {
 566	fc, err := ec.fieldContext_GitChangedFileConnection_nodes(ctx, field)
 567	if err != nil {
 568		return graphql.Null
 569	}
 570	ctx = graphql.WithFieldContext(ctx, fc)
 571	defer func() {
 572		if r := recover(); r != nil {
 573			ec.Error(ctx, ec.Recover(ctx, r))
 574			ret = graphql.Null
 575		}
 576	}()
 577	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 578		ctx = rctx // use context from middleware stack in children
 579		return obj.Nodes, nil
 580	})
 581	if err != nil {
 582		ec.Error(ctx, err)
 583		return graphql.Null
 584	}
 585	if resTmp == nil {
 586		if !graphql.HasFieldError(ctx, fc) {
 587			ec.Errorf(ctx, "must not be null")
 588		}
 589		return graphql.Null
 590	}
 591	res := resTmp.([]*repository.ChangedFile)
 592	fc.Result = res
 593	return ec.marshalNGitChangedFile2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangedFileᚄ(ctx, field.Selections, res)
 594}
 595
 596func (ec *executionContext) fieldContext_GitChangedFileConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 597	fc = &graphql.FieldContext{
 598		Object:     "GitChangedFileConnection",
 599		Field:      field,
 600		IsMethod:   false,
 601		IsResolver: false,
 602		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 603			switch field.Name {
 604			case "path":
 605				return ec.fieldContext_GitChangedFile_path(ctx, field)
 606			case "oldPath":
 607				return ec.fieldContext_GitChangedFile_oldPath(ctx, field)
 608			case "status":
 609				return ec.fieldContext_GitChangedFile_status(ctx, field)
 610			}
 611			return nil, fmt.Errorf("no field named %q was found under type GitChangedFile", field.Name)
 612		},
 613	}
 614	return fc, nil
 615}
 616
 617func (ec *executionContext) _GitChangedFileConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.GitChangedFileConnection) (ret graphql.Marshaler) {
 618	fc, err := ec.fieldContext_GitChangedFileConnection_pageInfo(ctx, field)
 619	if err != nil {
 620		return graphql.Null
 621	}
 622	ctx = graphql.WithFieldContext(ctx, fc)
 623	defer func() {
 624		if r := recover(); r != nil {
 625			ec.Error(ctx, ec.Recover(ctx, r))
 626			ret = graphql.Null
 627		}
 628	}()
 629	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 630		ctx = rctx // use context from middleware stack in children
 631		return obj.PageInfo, nil
 632	})
 633	if err != nil {
 634		ec.Error(ctx, err)
 635		return graphql.Null
 636	}
 637	if resTmp == nil {
 638		if !graphql.HasFieldError(ctx, fc) {
 639			ec.Errorf(ctx, "must not be null")
 640		}
 641		return graphql.Null
 642	}
 643	res := resTmp.(*models.PageInfo)
 644	fc.Result = res
 645	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 646}
 647
 648func (ec *executionContext) fieldContext_GitChangedFileConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 649	fc = &graphql.FieldContext{
 650		Object:     "GitChangedFileConnection",
 651		Field:      field,
 652		IsMethod:   false,
 653		IsResolver: false,
 654		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 655			switch field.Name {
 656			case "hasNextPage":
 657				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
 658			case "hasPreviousPage":
 659				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
 660			case "startCursor":
 661				return ec.fieldContext_PageInfo_startCursor(ctx, field)
 662			case "endCursor":
 663				return ec.fieldContext_PageInfo_endCursor(ctx, field)
 664			}
 665			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
 666		},
 667	}
 668	return fc, nil
 669}
 670
 671func (ec *executionContext) _GitChangedFileConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.GitChangedFileConnection) (ret graphql.Marshaler) {
 672	fc, err := ec.fieldContext_GitChangedFileConnection_totalCount(ctx, field)
 673	if err != nil {
 674		return graphql.Null
 675	}
 676	ctx = graphql.WithFieldContext(ctx, fc)
 677	defer func() {
 678		if r := recover(); r != nil {
 679			ec.Error(ctx, ec.Recover(ctx, r))
 680			ret = graphql.Null
 681		}
 682	}()
 683	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 684		ctx = rctx // use context from middleware stack in children
 685		return obj.TotalCount, nil
 686	})
 687	if err != nil {
 688		ec.Error(ctx, err)
 689		return graphql.Null
 690	}
 691	if resTmp == nil {
 692		if !graphql.HasFieldError(ctx, fc) {
 693			ec.Errorf(ctx, "must not be null")
 694		}
 695		return graphql.Null
 696	}
 697	res := resTmp.(int)
 698	fc.Result = res
 699	return ec.marshalNInt2int(ctx, field.Selections, res)
 700}
 701
 702func (ec *executionContext) fieldContext_GitChangedFileConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 703	fc = &graphql.FieldContext{
 704		Object:     "GitChangedFileConnection",
 705		Field:      field,
 706		IsMethod:   false,
 707		IsResolver: false,
 708		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 709			return nil, errors.New("field of type Int does not have child fields")
 710		},
 711	}
 712	return fc, nil
 713}
 714
 715func (ec *executionContext) _GitCommit_hash(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 716	fc, err := ec.fieldContext_GitCommit_hash(ctx, field)
 717	if err != nil {
 718		return graphql.Null
 719	}
 720	ctx = graphql.WithFieldContext(ctx, fc)
 721	defer func() {
 722		if r := recover(); r != nil {
 723			ec.Error(ctx, ec.Recover(ctx, r))
 724			ret = graphql.Null
 725		}
 726	}()
 727	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 728		ctx = rctx // use context from middleware stack in children
 729		return obj.Hash, nil
 730	})
 731	if err != nil {
 732		ec.Error(ctx, err)
 733		return graphql.Null
 734	}
 735	if resTmp == nil {
 736		if !graphql.HasFieldError(ctx, fc) {
 737			ec.Errorf(ctx, "must not be null")
 738		}
 739		return graphql.Null
 740	}
 741	res := resTmp.(repository.Hash)
 742	fc.Result = res
 743	return ec.marshalNString2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHash(ctx, field.Selections, res)
 744}
 745
 746func (ec *executionContext) fieldContext_GitCommit_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 747	fc = &graphql.FieldContext{
 748		Object:     "GitCommit",
 749		Field:      field,
 750		IsMethod:   false,
 751		IsResolver: false,
 752		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 753			return nil, errors.New("field of type String does not have child fields")
 754		},
 755	}
 756	return fc, nil
 757}
 758
 759func (ec *executionContext) _GitCommit_shortHash(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 760	fc, err := ec.fieldContext_GitCommit_shortHash(ctx, field)
 761	if err != nil {
 762		return graphql.Null
 763	}
 764	ctx = graphql.WithFieldContext(ctx, fc)
 765	defer func() {
 766		if r := recover(); r != nil {
 767			ec.Error(ctx, ec.Recover(ctx, r))
 768			ret = graphql.Null
 769		}
 770	}()
 771	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 772		ctx = rctx // use context from middleware stack in children
 773		return ec.resolvers.GitCommit().ShortHash(rctx, obj)
 774	})
 775	if err != nil {
 776		ec.Error(ctx, err)
 777		return graphql.Null
 778	}
 779	if resTmp == nil {
 780		if !graphql.HasFieldError(ctx, fc) {
 781			ec.Errorf(ctx, "must not be null")
 782		}
 783		return graphql.Null
 784	}
 785	res := resTmp.(string)
 786	fc.Result = res
 787	return ec.marshalNString2string(ctx, field.Selections, res)
 788}
 789
 790func (ec *executionContext) fieldContext_GitCommit_shortHash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 791	fc = &graphql.FieldContext{
 792		Object:     "GitCommit",
 793		Field:      field,
 794		IsMethod:   true,
 795		IsResolver: true,
 796		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 797			return nil, errors.New("field of type String does not have child fields")
 798		},
 799	}
 800	return fc, nil
 801}
 802
 803func (ec *executionContext) _GitCommit_message(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 804	fc, err := ec.fieldContext_GitCommit_message(ctx, field)
 805	if err != nil {
 806		return graphql.Null
 807	}
 808	ctx = graphql.WithFieldContext(ctx, fc)
 809	defer func() {
 810		if r := recover(); r != nil {
 811			ec.Error(ctx, ec.Recover(ctx, r))
 812			ret = graphql.Null
 813		}
 814	}()
 815	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 816		ctx = rctx // use context from middleware stack in children
 817		return obj.Message, nil
 818	})
 819	if err != nil {
 820		ec.Error(ctx, err)
 821		return graphql.Null
 822	}
 823	if resTmp == nil {
 824		if !graphql.HasFieldError(ctx, fc) {
 825			ec.Errorf(ctx, "must not be null")
 826		}
 827		return graphql.Null
 828	}
 829	res := resTmp.(string)
 830	fc.Result = res
 831	return ec.marshalNString2string(ctx, field.Selections, res)
 832}
 833
 834func (ec *executionContext) fieldContext_GitCommit_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 835	fc = &graphql.FieldContext{
 836		Object:     "GitCommit",
 837		Field:      field,
 838		IsMethod:   false,
 839		IsResolver: false,
 840		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 841			return nil, errors.New("field of type String does not have child fields")
 842		},
 843	}
 844	return fc, nil
 845}
 846
 847func (ec *executionContext) _GitCommit_fullMessage(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 848	fc, err := ec.fieldContext_GitCommit_fullMessage(ctx, field)
 849	if err != nil {
 850		return graphql.Null
 851	}
 852	ctx = graphql.WithFieldContext(ctx, fc)
 853	defer func() {
 854		if r := recover(); r != nil {
 855			ec.Error(ctx, ec.Recover(ctx, r))
 856			ret = graphql.Null
 857		}
 858	}()
 859	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 860		ctx = rctx // use context from middleware stack in children
 861		return ec.resolvers.GitCommit().FullMessage(rctx, obj)
 862	})
 863	if err != nil {
 864		ec.Error(ctx, err)
 865		return graphql.Null
 866	}
 867	if resTmp == nil {
 868		if !graphql.HasFieldError(ctx, fc) {
 869			ec.Errorf(ctx, "must not be null")
 870		}
 871		return graphql.Null
 872	}
 873	res := resTmp.(string)
 874	fc.Result = res
 875	return ec.marshalNString2string(ctx, field.Selections, res)
 876}
 877
 878func (ec *executionContext) fieldContext_GitCommit_fullMessage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 879	fc = &graphql.FieldContext{
 880		Object:     "GitCommit",
 881		Field:      field,
 882		IsMethod:   true,
 883		IsResolver: true,
 884		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 885			return nil, errors.New("field of type String does not have child fields")
 886		},
 887	}
 888	return fc, nil
 889}
 890
 891func (ec *executionContext) _GitCommit_authorName(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 892	fc, err := ec.fieldContext_GitCommit_authorName(ctx, field)
 893	if err != nil {
 894		return graphql.Null
 895	}
 896	ctx = graphql.WithFieldContext(ctx, fc)
 897	defer func() {
 898		if r := recover(); r != nil {
 899			ec.Error(ctx, ec.Recover(ctx, r))
 900			ret = graphql.Null
 901		}
 902	}()
 903	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 904		ctx = rctx // use context from middleware stack in children
 905		return obj.AuthorName, nil
 906	})
 907	if err != nil {
 908		ec.Error(ctx, err)
 909		return graphql.Null
 910	}
 911	if resTmp == nil {
 912		if !graphql.HasFieldError(ctx, fc) {
 913			ec.Errorf(ctx, "must not be null")
 914		}
 915		return graphql.Null
 916	}
 917	res := resTmp.(string)
 918	fc.Result = res
 919	return ec.marshalNString2string(ctx, field.Selections, res)
 920}
 921
 922func (ec *executionContext) fieldContext_GitCommit_authorName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 923	fc = &graphql.FieldContext{
 924		Object:     "GitCommit",
 925		Field:      field,
 926		IsMethod:   false,
 927		IsResolver: false,
 928		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 929			return nil, errors.New("field of type String does not have child fields")
 930		},
 931	}
 932	return fc, nil
 933}
 934
 935func (ec *executionContext) _GitCommit_authorEmail(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 936	fc, err := ec.fieldContext_GitCommit_authorEmail(ctx, field)
 937	if err != nil {
 938		return graphql.Null
 939	}
 940	ctx = graphql.WithFieldContext(ctx, fc)
 941	defer func() {
 942		if r := recover(); r != nil {
 943			ec.Error(ctx, ec.Recover(ctx, r))
 944			ret = graphql.Null
 945		}
 946	}()
 947	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 948		ctx = rctx // use context from middleware stack in children
 949		return obj.AuthorEmail, nil
 950	})
 951	if err != nil {
 952		ec.Error(ctx, err)
 953		return graphql.Null
 954	}
 955	if resTmp == nil {
 956		if !graphql.HasFieldError(ctx, fc) {
 957			ec.Errorf(ctx, "must not be null")
 958		}
 959		return graphql.Null
 960	}
 961	res := resTmp.(string)
 962	fc.Result = res
 963	return ec.marshalNString2string(ctx, field.Selections, res)
 964}
 965
 966func (ec *executionContext) fieldContext_GitCommit_authorEmail(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 967	fc = &graphql.FieldContext{
 968		Object:     "GitCommit",
 969		Field:      field,
 970		IsMethod:   false,
 971		IsResolver: false,
 972		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 973			return nil, errors.New("field of type String does not have child fields")
 974		},
 975	}
 976	return fc, nil
 977}
 978
 979func (ec *executionContext) _GitCommit_date(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
 980	fc, err := ec.fieldContext_GitCommit_date(ctx, field)
 981	if err != nil {
 982		return graphql.Null
 983	}
 984	ctx = graphql.WithFieldContext(ctx, fc)
 985	defer func() {
 986		if r := recover(); r != nil {
 987			ec.Error(ctx, ec.Recover(ctx, r))
 988			ret = graphql.Null
 989		}
 990	}()
 991	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 992		ctx = rctx // use context from middleware stack in children
 993		return obj.Date, nil
 994	})
 995	if err != nil {
 996		ec.Error(ctx, err)
 997		return graphql.Null
 998	}
 999	if resTmp == nil {
1000		if !graphql.HasFieldError(ctx, fc) {
1001			ec.Errorf(ctx, "must not be null")
1002		}
1003		return graphql.Null
1004	}
1005	res := resTmp.(time.Time)
1006	fc.Result = res
1007	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
1008}
1009
1010func (ec *executionContext) fieldContext_GitCommit_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1011	fc = &graphql.FieldContext{
1012		Object:     "GitCommit",
1013		Field:      field,
1014		IsMethod:   false,
1015		IsResolver: false,
1016		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1017			return nil, errors.New("field of type Time does not have child fields")
1018		},
1019	}
1020	return fc, nil
1021}
1022
1023func (ec *executionContext) _GitCommit_parents(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
1024	fc, err := ec.fieldContext_GitCommit_parents(ctx, field)
1025	if err != nil {
1026		return graphql.Null
1027	}
1028	ctx = graphql.WithFieldContext(ctx, fc)
1029	defer func() {
1030		if r := recover(); r != nil {
1031			ec.Error(ctx, ec.Recover(ctx, r))
1032			ret = graphql.Null
1033		}
1034	}()
1035	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1036		ctx = rctx // use context from middleware stack in children
1037		return ec.resolvers.GitCommit().Parents(rctx, obj)
1038	})
1039	if err != nil {
1040		ec.Error(ctx, err)
1041		return graphql.Null
1042	}
1043	if resTmp == nil {
1044		if !graphql.HasFieldError(ctx, fc) {
1045			ec.Errorf(ctx, "must not be null")
1046		}
1047		return graphql.Null
1048	}
1049	res := resTmp.([]string)
1050	fc.Result = res
1051	return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
1052}
1053
1054func (ec *executionContext) fieldContext_GitCommit_parents(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1055	fc = &graphql.FieldContext{
1056		Object:     "GitCommit",
1057		Field:      field,
1058		IsMethod:   true,
1059		IsResolver: true,
1060		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1061			return nil, errors.New("field of type String does not have child fields")
1062		},
1063	}
1064	return fc, nil
1065}
1066
1067func (ec *executionContext) _GitCommit_files(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
1068	fc, err := ec.fieldContext_GitCommit_files(ctx, field)
1069	if err != nil {
1070		return graphql.Null
1071	}
1072	ctx = graphql.WithFieldContext(ctx, fc)
1073	defer func() {
1074		if r := recover(); r != nil {
1075			ec.Error(ctx, ec.Recover(ctx, r))
1076			ret = graphql.Null
1077		}
1078	}()
1079	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1080		ctx = rctx // use context from middleware stack in children
1081		return ec.resolvers.GitCommit().Files(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1082	})
1083	if err != nil {
1084		ec.Error(ctx, err)
1085		return graphql.Null
1086	}
1087	if resTmp == nil {
1088		if !graphql.HasFieldError(ctx, fc) {
1089			ec.Errorf(ctx, "must not be null")
1090		}
1091		return graphql.Null
1092	}
1093	res := resTmp.(*models.GitChangedFileConnection)
1094	fc.Result = res
1095	return ec.marshalNGitChangedFileConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitChangedFileConnection(ctx, field.Selections, res)
1096}
1097
1098func (ec *executionContext) fieldContext_GitCommit_files(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1099	fc = &graphql.FieldContext{
1100		Object:     "GitCommit",
1101		Field:      field,
1102		IsMethod:   true,
1103		IsResolver: true,
1104		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1105			switch field.Name {
1106			case "nodes":
1107				return ec.fieldContext_GitChangedFileConnection_nodes(ctx, field)
1108			case "pageInfo":
1109				return ec.fieldContext_GitChangedFileConnection_pageInfo(ctx, field)
1110			case "totalCount":
1111				return ec.fieldContext_GitChangedFileConnection_totalCount(ctx, field)
1112			}
1113			return nil, fmt.Errorf("no field named %q was found under type GitChangedFileConnection", field.Name)
1114		},
1115	}
1116	defer func() {
1117		if r := recover(); r != nil {
1118			err = ec.Recover(ctx, r)
1119			ec.Error(ctx, err)
1120		}
1121	}()
1122	ctx = graphql.WithFieldContext(ctx, fc)
1123	if fc.Args, err = ec.field_GitCommit_files_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1124		ec.Error(ctx, err)
1125		return fc, err
1126	}
1127	return fc, nil
1128}
1129
1130func (ec *executionContext) _GitCommit_diff(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitMeta) (ret graphql.Marshaler) {
1131	fc, err := ec.fieldContext_GitCommit_diff(ctx, field)
1132	if err != nil {
1133		return graphql.Null
1134	}
1135	ctx = graphql.WithFieldContext(ctx, fc)
1136	defer func() {
1137		if r := recover(); r != nil {
1138			ec.Error(ctx, ec.Recover(ctx, r))
1139			ret = graphql.Null
1140		}
1141	}()
1142	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1143		ctx = rctx // use context from middleware stack in children
1144		return ec.resolvers.GitCommit().Diff(rctx, obj, fc.Args["path"].(string))
1145	})
1146	if err != nil {
1147		ec.Error(ctx, err)
1148		return graphql.Null
1149	}
1150	if resTmp == nil {
1151		return graphql.Null
1152	}
1153	res := resTmp.(*repository.FileDiff)
1154	fc.Result = res
1155	return ec.marshalOGitFileDiff2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐFileDiff(ctx, field.Selections, res)
1156}
1157
1158func (ec *executionContext) fieldContext_GitCommit_diff(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1159	fc = &graphql.FieldContext{
1160		Object:     "GitCommit",
1161		Field:      field,
1162		IsMethod:   true,
1163		IsResolver: true,
1164		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1165			switch field.Name {
1166			case "path":
1167				return ec.fieldContext_GitFileDiff_path(ctx, field)
1168			case "oldPath":
1169				return ec.fieldContext_GitFileDiff_oldPath(ctx, field)
1170			case "isBinary":
1171				return ec.fieldContext_GitFileDiff_isBinary(ctx, field)
1172			case "isNew":
1173				return ec.fieldContext_GitFileDiff_isNew(ctx, field)
1174			case "isDelete":
1175				return ec.fieldContext_GitFileDiff_isDelete(ctx, field)
1176			case "hunks":
1177				return ec.fieldContext_GitFileDiff_hunks(ctx, field)
1178			}
1179			return nil, fmt.Errorf("no field named %q was found under type GitFileDiff", field.Name)
1180		},
1181	}
1182	defer func() {
1183		if r := recover(); r != nil {
1184			err = ec.Recover(ctx, r)
1185			ec.Error(ctx, err)
1186		}
1187	}()
1188	ctx = graphql.WithFieldContext(ctx, fc)
1189	if fc.Args, err = ec.field_GitCommit_diff_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1190		ec.Error(ctx, err)
1191		return fc, err
1192	}
1193	return fc, nil
1194}
1195
1196func (ec *executionContext) _GitCommitConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitConnection) (ret graphql.Marshaler) {
1197	fc, err := ec.fieldContext_GitCommitConnection_nodes(ctx, field)
1198	if err != nil {
1199		return graphql.Null
1200	}
1201	ctx = graphql.WithFieldContext(ctx, fc)
1202	defer func() {
1203		if r := recover(); r != nil {
1204			ec.Error(ctx, ec.Recover(ctx, r))
1205			ret = graphql.Null
1206		}
1207	}()
1208	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1209		ctx = rctx // use context from middleware stack in children
1210		return obj.Nodes, nil
1211	})
1212	if err != nil {
1213		ec.Error(ctx, err)
1214		return graphql.Null
1215	}
1216	if resTmp == nil {
1217		if !graphql.HasFieldError(ctx, fc) {
1218			ec.Errorf(ctx, "must not be null")
1219		}
1220		return graphql.Null
1221	}
1222	res := resTmp.([]*models.GitCommitMeta)
1223	fc.Result = res
1224	return ec.marshalNGitCommit2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMetaᚄ(ctx, field.Selections, res)
1225}
1226
1227func (ec *executionContext) fieldContext_GitCommitConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1228	fc = &graphql.FieldContext{
1229		Object:     "GitCommitConnection",
1230		Field:      field,
1231		IsMethod:   false,
1232		IsResolver: false,
1233		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1234			switch field.Name {
1235			case "hash":
1236				return ec.fieldContext_GitCommit_hash(ctx, field)
1237			case "shortHash":
1238				return ec.fieldContext_GitCommit_shortHash(ctx, field)
1239			case "message":
1240				return ec.fieldContext_GitCommit_message(ctx, field)
1241			case "fullMessage":
1242				return ec.fieldContext_GitCommit_fullMessage(ctx, field)
1243			case "authorName":
1244				return ec.fieldContext_GitCommit_authorName(ctx, field)
1245			case "authorEmail":
1246				return ec.fieldContext_GitCommit_authorEmail(ctx, field)
1247			case "date":
1248				return ec.fieldContext_GitCommit_date(ctx, field)
1249			case "parents":
1250				return ec.fieldContext_GitCommit_parents(ctx, field)
1251			case "files":
1252				return ec.fieldContext_GitCommit_files(ctx, field)
1253			case "diff":
1254				return ec.fieldContext_GitCommit_diff(ctx, field)
1255			}
1256			return nil, fmt.Errorf("no field named %q was found under type GitCommit", field.Name)
1257		},
1258	}
1259	return fc, nil
1260}
1261
1262func (ec *executionContext) _GitCommitConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitConnection) (ret graphql.Marshaler) {
1263	fc, err := ec.fieldContext_GitCommitConnection_pageInfo(ctx, field)
1264	if err != nil {
1265		return graphql.Null
1266	}
1267	ctx = graphql.WithFieldContext(ctx, fc)
1268	defer func() {
1269		if r := recover(); r != nil {
1270			ec.Error(ctx, ec.Recover(ctx, r))
1271			ret = graphql.Null
1272		}
1273	}()
1274	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1275		ctx = rctx // use context from middleware stack in children
1276		return obj.PageInfo, nil
1277	})
1278	if err != nil {
1279		ec.Error(ctx, err)
1280		return graphql.Null
1281	}
1282	if resTmp == nil {
1283		if !graphql.HasFieldError(ctx, fc) {
1284			ec.Errorf(ctx, "must not be null")
1285		}
1286		return graphql.Null
1287	}
1288	res := resTmp.(*models.PageInfo)
1289	fc.Result = res
1290	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
1291}
1292
1293func (ec *executionContext) fieldContext_GitCommitConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1294	fc = &graphql.FieldContext{
1295		Object:     "GitCommitConnection",
1296		Field:      field,
1297		IsMethod:   false,
1298		IsResolver: false,
1299		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1300			switch field.Name {
1301			case "hasNextPage":
1302				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
1303			case "hasPreviousPage":
1304				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
1305			case "startCursor":
1306				return ec.fieldContext_PageInfo_startCursor(ctx, field)
1307			case "endCursor":
1308				return ec.fieldContext_PageInfo_endCursor(ctx, field)
1309			}
1310			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
1311		},
1312	}
1313	return fc, nil
1314}
1315
1316func (ec *executionContext) _GitCommitConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.GitCommitConnection) (ret graphql.Marshaler) {
1317	fc, err := ec.fieldContext_GitCommitConnection_totalCount(ctx, field)
1318	if err != nil {
1319		return graphql.Null
1320	}
1321	ctx = graphql.WithFieldContext(ctx, fc)
1322	defer func() {
1323		if r := recover(); r != nil {
1324			ec.Error(ctx, ec.Recover(ctx, r))
1325			ret = graphql.Null
1326		}
1327	}()
1328	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1329		ctx = rctx // use context from middleware stack in children
1330		return obj.TotalCount, nil
1331	})
1332	if err != nil {
1333		ec.Error(ctx, err)
1334		return graphql.Null
1335	}
1336	if resTmp == nil {
1337		if !graphql.HasFieldError(ctx, fc) {
1338			ec.Errorf(ctx, "must not be null")
1339		}
1340		return graphql.Null
1341	}
1342	res := resTmp.(int)
1343	fc.Result = res
1344	return ec.marshalNInt2int(ctx, field.Selections, res)
1345}
1346
1347func (ec *executionContext) fieldContext_GitCommitConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1348	fc = &graphql.FieldContext{
1349		Object:     "GitCommitConnection",
1350		Field:      field,
1351		IsMethod:   false,
1352		IsResolver: false,
1353		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1354			return nil, errors.New("field of type Int does not have child fields")
1355		},
1356	}
1357	return fc, nil
1358}
1359
1360func (ec *executionContext) _GitDiffHunk_oldStart(ctx context.Context, field graphql.CollectedField, obj *repository.DiffHunk) (ret graphql.Marshaler) {
1361	fc, err := ec.fieldContext_GitDiffHunk_oldStart(ctx, field)
1362	if err != nil {
1363		return graphql.Null
1364	}
1365	ctx = graphql.WithFieldContext(ctx, fc)
1366	defer func() {
1367		if r := recover(); r != nil {
1368			ec.Error(ctx, ec.Recover(ctx, r))
1369			ret = graphql.Null
1370		}
1371	}()
1372	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1373		ctx = rctx // use context from middleware stack in children
1374		return obj.OldStart, nil
1375	})
1376	if err != nil {
1377		ec.Error(ctx, err)
1378		return graphql.Null
1379	}
1380	if resTmp == nil {
1381		if !graphql.HasFieldError(ctx, fc) {
1382			ec.Errorf(ctx, "must not be null")
1383		}
1384		return graphql.Null
1385	}
1386	res := resTmp.(int)
1387	fc.Result = res
1388	return ec.marshalNInt2int(ctx, field.Selections, res)
1389}
1390
1391func (ec *executionContext) fieldContext_GitDiffHunk_oldStart(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1392	fc = &graphql.FieldContext{
1393		Object:     "GitDiffHunk",
1394		Field:      field,
1395		IsMethod:   false,
1396		IsResolver: false,
1397		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1398			return nil, errors.New("field of type Int does not have child fields")
1399		},
1400	}
1401	return fc, nil
1402}
1403
1404func (ec *executionContext) _GitDiffHunk_oldLines(ctx context.Context, field graphql.CollectedField, obj *repository.DiffHunk) (ret graphql.Marshaler) {
1405	fc, err := ec.fieldContext_GitDiffHunk_oldLines(ctx, field)
1406	if err != nil {
1407		return graphql.Null
1408	}
1409	ctx = graphql.WithFieldContext(ctx, fc)
1410	defer func() {
1411		if r := recover(); r != nil {
1412			ec.Error(ctx, ec.Recover(ctx, r))
1413			ret = graphql.Null
1414		}
1415	}()
1416	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1417		ctx = rctx // use context from middleware stack in children
1418		return obj.OldLines, nil
1419	})
1420	if err != nil {
1421		ec.Error(ctx, err)
1422		return graphql.Null
1423	}
1424	if resTmp == nil {
1425		if !graphql.HasFieldError(ctx, fc) {
1426			ec.Errorf(ctx, "must not be null")
1427		}
1428		return graphql.Null
1429	}
1430	res := resTmp.(int)
1431	fc.Result = res
1432	return ec.marshalNInt2int(ctx, field.Selections, res)
1433}
1434
1435func (ec *executionContext) fieldContext_GitDiffHunk_oldLines(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1436	fc = &graphql.FieldContext{
1437		Object:     "GitDiffHunk",
1438		Field:      field,
1439		IsMethod:   false,
1440		IsResolver: false,
1441		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1442			return nil, errors.New("field of type Int does not have child fields")
1443		},
1444	}
1445	return fc, nil
1446}
1447
1448func (ec *executionContext) _GitDiffHunk_newStart(ctx context.Context, field graphql.CollectedField, obj *repository.DiffHunk) (ret graphql.Marshaler) {
1449	fc, err := ec.fieldContext_GitDiffHunk_newStart(ctx, field)
1450	if err != nil {
1451		return graphql.Null
1452	}
1453	ctx = graphql.WithFieldContext(ctx, fc)
1454	defer func() {
1455		if r := recover(); r != nil {
1456			ec.Error(ctx, ec.Recover(ctx, r))
1457			ret = graphql.Null
1458		}
1459	}()
1460	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1461		ctx = rctx // use context from middleware stack in children
1462		return obj.NewStart, nil
1463	})
1464	if err != nil {
1465		ec.Error(ctx, err)
1466		return graphql.Null
1467	}
1468	if resTmp == nil {
1469		if !graphql.HasFieldError(ctx, fc) {
1470			ec.Errorf(ctx, "must not be null")
1471		}
1472		return graphql.Null
1473	}
1474	res := resTmp.(int)
1475	fc.Result = res
1476	return ec.marshalNInt2int(ctx, field.Selections, res)
1477}
1478
1479func (ec *executionContext) fieldContext_GitDiffHunk_newStart(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1480	fc = &graphql.FieldContext{
1481		Object:     "GitDiffHunk",
1482		Field:      field,
1483		IsMethod:   false,
1484		IsResolver: false,
1485		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1486			return nil, errors.New("field of type Int does not have child fields")
1487		},
1488	}
1489	return fc, nil
1490}
1491
1492func (ec *executionContext) _GitDiffHunk_newLines(ctx context.Context, field graphql.CollectedField, obj *repository.DiffHunk) (ret graphql.Marshaler) {
1493	fc, err := ec.fieldContext_GitDiffHunk_newLines(ctx, field)
1494	if err != nil {
1495		return graphql.Null
1496	}
1497	ctx = graphql.WithFieldContext(ctx, fc)
1498	defer func() {
1499		if r := recover(); r != nil {
1500			ec.Error(ctx, ec.Recover(ctx, r))
1501			ret = graphql.Null
1502		}
1503	}()
1504	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1505		ctx = rctx // use context from middleware stack in children
1506		return obj.NewLines, nil
1507	})
1508	if err != nil {
1509		ec.Error(ctx, err)
1510		return graphql.Null
1511	}
1512	if resTmp == nil {
1513		if !graphql.HasFieldError(ctx, fc) {
1514			ec.Errorf(ctx, "must not be null")
1515		}
1516		return graphql.Null
1517	}
1518	res := resTmp.(int)
1519	fc.Result = res
1520	return ec.marshalNInt2int(ctx, field.Selections, res)
1521}
1522
1523func (ec *executionContext) fieldContext_GitDiffHunk_newLines(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1524	fc = &graphql.FieldContext{
1525		Object:     "GitDiffHunk",
1526		Field:      field,
1527		IsMethod:   false,
1528		IsResolver: false,
1529		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1530			return nil, errors.New("field of type Int does not have child fields")
1531		},
1532	}
1533	return fc, nil
1534}
1535
1536func (ec *executionContext) _GitDiffHunk_lines(ctx context.Context, field graphql.CollectedField, obj *repository.DiffHunk) (ret graphql.Marshaler) {
1537	fc, err := ec.fieldContext_GitDiffHunk_lines(ctx, field)
1538	if err != nil {
1539		return graphql.Null
1540	}
1541	ctx = graphql.WithFieldContext(ctx, fc)
1542	defer func() {
1543		if r := recover(); r != nil {
1544			ec.Error(ctx, ec.Recover(ctx, r))
1545			ret = graphql.Null
1546		}
1547	}()
1548	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1549		ctx = rctx // use context from middleware stack in children
1550		return obj.Lines, nil
1551	})
1552	if err != nil {
1553		ec.Error(ctx, err)
1554		return graphql.Null
1555	}
1556	if resTmp == nil {
1557		if !graphql.HasFieldError(ctx, fc) {
1558			ec.Errorf(ctx, "must not be null")
1559		}
1560		return graphql.Null
1561	}
1562	res := resTmp.([]repository.DiffLine)
1563	fc.Result = res
1564	return ec.marshalNGitDiffLine2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLineᚄ(ctx, field.Selections, res)
1565}
1566
1567func (ec *executionContext) fieldContext_GitDiffHunk_lines(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1568	fc = &graphql.FieldContext{
1569		Object:     "GitDiffHunk",
1570		Field:      field,
1571		IsMethod:   false,
1572		IsResolver: false,
1573		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1574			switch field.Name {
1575			case "type":
1576				return ec.fieldContext_GitDiffLine_type(ctx, field)
1577			case "content":
1578				return ec.fieldContext_GitDiffLine_content(ctx, field)
1579			case "oldLine":
1580				return ec.fieldContext_GitDiffLine_oldLine(ctx, field)
1581			case "newLine":
1582				return ec.fieldContext_GitDiffLine_newLine(ctx, field)
1583			}
1584			return nil, fmt.Errorf("no field named %q was found under type GitDiffLine", field.Name)
1585		},
1586	}
1587	return fc, nil
1588}
1589
1590func (ec *executionContext) _GitDiffLine_type(ctx context.Context, field graphql.CollectedField, obj *repository.DiffLine) (ret graphql.Marshaler) {
1591	fc, err := ec.fieldContext_GitDiffLine_type(ctx, field)
1592	if err != nil {
1593		return graphql.Null
1594	}
1595	ctx = graphql.WithFieldContext(ctx, fc)
1596	defer func() {
1597		if r := recover(); r != nil {
1598			ec.Error(ctx, ec.Recover(ctx, r))
1599			ret = graphql.Null
1600		}
1601	}()
1602	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1603		ctx = rctx // use context from middleware stack in children
1604		return obj.Type, nil
1605	})
1606	if err != nil {
1607		ec.Error(ctx, err)
1608		return graphql.Null
1609	}
1610	if resTmp == nil {
1611		if !graphql.HasFieldError(ctx, fc) {
1612			ec.Errorf(ctx, "must not be null")
1613		}
1614		return graphql.Null
1615	}
1616	res := resTmp.(repository.DiffLineType)
1617	fc.Result = res
1618	return ec.marshalNGitDiffLineType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLineType(ctx, field.Selections, res)
1619}
1620
1621func (ec *executionContext) fieldContext_GitDiffLine_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1622	fc = &graphql.FieldContext{
1623		Object:     "GitDiffLine",
1624		Field:      field,
1625		IsMethod:   false,
1626		IsResolver: false,
1627		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1628			return nil, errors.New("field of type GitDiffLineType does not have child fields")
1629		},
1630	}
1631	return fc, nil
1632}
1633
1634func (ec *executionContext) _GitDiffLine_content(ctx context.Context, field graphql.CollectedField, obj *repository.DiffLine) (ret graphql.Marshaler) {
1635	fc, err := ec.fieldContext_GitDiffLine_content(ctx, field)
1636	if err != nil {
1637		return graphql.Null
1638	}
1639	ctx = graphql.WithFieldContext(ctx, fc)
1640	defer func() {
1641		if r := recover(); r != nil {
1642			ec.Error(ctx, ec.Recover(ctx, r))
1643			ret = graphql.Null
1644		}
1645	}()
1646	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1647		ctx = rctx // use context from middleware stack in children
1648		return obj.Content, nil
1649	})
1650	if err != nil {
1651		ec.Error(ctx, err)
1652		return graphql.Null
1653	}
1654	if resTmp == nil {
1655		if !graphql.HasFieldError(ctx, fc) {
1656			ec.Errorf(ctx, "must not be null")
1657		}
1658		return graphql.Null
1659	}
1660	res := resTmp.(string)
1661	fc.Result = res
1662	return ec.marshalNString2string(ctx, field.Selections, res)
1663}
1664
1665func (ec *executionContext) fieldContext_GitDiffLine_content(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1666	fc = &graphql.FieldContext{
1667		Object:     "GitDiffLine",
1668		Field:      field,
1669		IsMethod:   false,
1670		IsResolver: false,
1671		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1672			return nil, errors.New("field of type String does not have child fields")
1673		},
1674	}
1675	return fc, nil
1676}
1677
1678func (ec *executionContext) _GitDiffLine_oldLine(ctx context.Context, field graphql.CollectedField, obj *repository.DiffLine) (ret graphql.Marshaler) {
1679	fc, err := ec.fieldContext_GitDiffLine_oldLine(ctx, field)
1680	if err != nil {
1681		return graphql.Null
1682	}
1683	ctx = graphql.WithFieldContext(ctx, fc)
1684	defer func() {
1685		if r := recover(); r != nil {
1686			ec.Error(ctx, ec.Recover(ctx, r))
1687			ret = graphql.Null
1688		}
1689	}()
1690	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1691		ctx = rctx // use context from middleware stack in children
1692		return obj.OldLine, nil
1693	})
1694	if err != nil {
1695		ec.Error(ctx, err)
1696		return graphql.Null
1697	}
1698	if resTmp == nil {
1699		if !graphql.HasFieldError(ctx, fc) {
1700			ec.Errorf(ctx, "must not be null")
1701		}
1702		return graphql.Null
1703	}
1704	res := resTmp.(int)
1705	fc.Result = res
1706	return ec.marshalNInt2int(ctx, field.Selections, res)
1707}
1708
1709func (ec *executionContext) fieldContext_GitDiffLine_oldLine(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1710	fc = &graphql.FieldContext{
1711		Object:     "GitDiffLine",
1712		Field:      field,
1713		IsMethod:   false,
1714		IsResolver: false,
1715		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1716			return nil, errors.New("field of type Int does not have child fields")
1717		},
1718	}
1719	return fc, nil
1720}
1721
1722func (ec *executionContext) _GitDiffLine_newLine(ctx context.Context, field graphql.CollectedField, obj *repository.DiffLine) (ret graphql.Marshaler) {
1723	fc, err := ec.fieldContext_GitDiffLine_newLine(ctx, field)
1724	if err != nil {
1725		return graphql.Null
1726	}
1727	ctx = graphql.WithFieldContext(ctx, fc)
1728	defer func() {
1729		if r := recover(); r != nil {
1730			ec.Error(ctx, ec.Recover(ctx, r))
1731			ret = graphql.Null
1732		}
1733	}()
1734	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1735		ctx = rctx // use context from middleware stack in children
1736		return obj.NewLine, nil
1737	})
1738	if err != nil {
1739		ec.Error(ctx, err)
1740		return graphql.Null
1741	}
1742	if resTmp == nil {
1743		if !graphql.HasFieldError(ctx, fc) {
1744			ec.Errorf(ctx, "must not be null")
1745		}
1746		return graphql.Null
1747	}
1748	res := resTmp.(int)
1749	fc.Result = res
1750	return ec.marshalNInt2int(ctx, field.Selections, res)
1751}
1752
1753func (ec *executionContext) fieldContext_GitDiffLine_newLine(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1754	fc = &graphql.FieldContext{
1755		Object:     "GitDiffLine",
1756		Field:      field,
1757		IsMethod:   false,
1758		IsResolver: false,
1759		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1760			return nil, errors.New("field of type Int does not have child fields")
1761		},
1762	}
1763	return fc, nil
1764}
1765
1766func (ec *executionContext) _GitFileDiff_path(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1767	fc, err := ec.fieldContext_GitFileDiff_path(ctx, field)
1768	if err != nil {
1769		return graphql.Null
1770	}
1771	ctx = graphql.WithFieldContext(ctx, fc)
1772	defer func() {
1773		if r := recover(); r != nil {
1774			ec.Error(ctx, ec.Recover(ctx, r))
1775			ret = graphql.Null
1776		}
1777	}()
1778	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1779		ctx = rctx // use context from middleware stack in children
1780		return obj.Path, nil
1781	})
1782	if err != nil {
1783		ec.Error(ctx, err)
1784		return graphql.Null
1785	}
1786	if resTmp == nil {
1787		if !graphql.HasFieldError(ctx, fc) {
1788			ec.Errorf(ctx, "must not be null")
1789		}
1790		return graphql.Null
1791	}
1792	res := resTmp.(string)
1793	fc.Result = res
1794	return ec.marshalNString2string(ctx, field.Selections, res)
1795}
1796
1797func (ec *executionContext) fieldContext_GitFileDiff_path(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1798	fc = &graphql.FieldContext{
1799		Object:     "GitFileDiff",
1800		Field:      field,
1801		IsMethod:   false,
1802		IsResolver: false,
1803		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1804			return nil, errors.New("field of type String does not have child fields")
1805		},
1806	}
1807	return fc, nil
1808}
1809
1810func (ec *executionContext) _GitFileDiff_oldPath(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1811	fc, err := ec.fieldContext_GitFileDiff_oldPath(ctx, field)
1812	if err != nil {
1813		return graphql.Null
1814	}
1815	ctx = graphql.WithFieldContext(ctx, fc)
1816	defer func() {
1817		if r := recover(); r != nil {
1818			ec.Error(ctx, ec.Recover(ctx, r))
1819			ret = graphql.Null
1820		}
1821	}()
1822	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1823		ctx = rctx // use context from middleware stack in children
1824		return obj.OldPath, nil
1825	})
1826	if err != nil {
1827		ec.Error(ctx, err)
1828		return graphql.Null
1829	}
1830	if resTmp == nil {
1831		return graphql.Null
1832	}
1833	res := resTmp.(*string)
1834	fc.Result = res
1835	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1836}
1837
1838func (ec *executionContext) fieldContext_GitFileDiff_oldPath(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1839	fc = &graphql.FieldContext{
1840		Object:     "GitFileDiff",
1841		Field:      field,
1842		IsMethod:   false,
1843		IsResolver: false,
1844		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1845			return nil, errors.New("field of type String does not have child fields")
1846		},
1847	}
1848	return fc, nil
1849}
1850
1851func (ec *executionContext) _GitFileDiff_isBinary(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1852	fc, err := ec.fieldContext_GitFileDiff_isBinary(ctx, field)
1853	if err != nil {
1854		return graphql.Null
1855	}
1856	ctx = graphql.WithFieldContext(ctx, fc)
1857	defer func() {
1858		if r := recover(); r != nil {
1859			ec.Error(ctx, ec.Recover(ctx, r))
1860			ret = graphql.Null
1861		}
1862	}()
1863	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1864		ctx = rctx // use context from middleware stack in children
1865		return obj.IsBinary, nil
1866	})
1867	if err != nil {
1868		ec.Error(ctx, err)
1869		return graphql.Null
1870	}
1871	if resTmp == nil {
1872		if !graphql.HasFieldError(ctx, fc) {
1873			ec.Errorf(ctx, "must not be null")
1874		}
1875		return graphql.Null
1876	}
1877	res := resTmp.(bool)
1878	fc.Result = res
1879	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
1880}
1881
1882func (ec *executionContext) fieldContext_GitFileDiff_isBinary(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1883	fc = &graphql.FieldContext{
1884		Object:     "GitFileDiff",
1885		Field:      field,
1886		IsMethod:   false,
1887		IsResolver: false,
1888		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1889			return nil, errors.New("field of type Boolean does not have child fields")
1890		},
1891	}
1892	return fc, nil
1893}
1894
1895func (ec *executionContext) _GitFileDiff_isNew(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1896	fc, err := ec.fieldContext_GitFileDiff_isNew(ctx, field)
1897	if err != nil {
1898		return graphql.Null
1899	}
1900	ctx = graphql.WithFieldContext(ctx, fc)
1901	defer func() {
1902		if r := recover(); r != nil {
1903			ec.Error(ctx, ec.Recover(ctx, r))
1904			ret = graphql.Null
1905		}
1906	}()
1907	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1908		ctx = rctx // use context from middleware stack in children
1909		return obj.IsNew, nil
1910	})
1911	if err != nil {
1912		ec.Error(ctx, err)
1913		return graphql.Null
1914	}
1915	if resTmp == nil {
1916		if !graphql.HasFieldError(ctx, fc) {
1917			ec.Errorf(ctx, "must not be null")
1918		}
1919		return graphql.Null
1920	}
1921	res := resTmp.(bool)
1922	fc.Result = res
1923	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
1924}
1925
1926func (ec *executionContext) fieldContext_GitFileDiff_isNew(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1927	fc = &graphql.FieldContext{
1928		Object:     "GitFileDiff",
1929		Field:      field,
1930		IsMethod:   false,
1931		IsResolver: false,
1932		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1933			return nil, errors.New("field of type Boolean does not have child fields")
1934		},
1935	}
1936	return fc, nil
1937}
1938
1939func (ec *executionContext) _GitFileDiff_isDelete(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1940	fc, err := ec.fieldContext_GitFileDiff_isDelete(ctx, field)
1941	if err != nil {
1942		return graphql.Null
1943	}
1944	ctx = graphql.WithFieldContext(ctx, fc)
1945	defer func() {
1946		if r := recover(); r != nil {
1947			ec.Error(ctx, ec.Recover(ctx, r))
1948			ret = graphql.Null
1949		}
1950	}()
1951	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1952		ctx = rctx // use context from middleware stack in children
1953		return obj.IsDelete, nil
1954	})
1955	if err != nil {
1956		ec.Error(ctx, err)
1957		return graphql.Null
1958	}
1959	if resTmp == nil {
1960		if !graphql.HasFieldError(ctx, fc) {
1961			ec.Errorf(ctx, "must not be null")
1962		}
1963		return graphql.Null
1964	}
1965	res := resTmp.(bool)
1966	fc.Result = res
1967	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
1968}
1969
1970func (ec *executionContext) fieldContext_GitFileDiff_isDelete(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1971	fc = &graphql.FieldContext{
1972		Object:     "GitFileDiff",
1973		Field:      field,
1974		IsMethod:   false,
1975		IsResolver: false,
1976		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1977			return nil, errors.New("field of type Boolean does not have child fields")
1978		},
1979	}
1980	return fc, nil
1981}
1982
1983func (ec *executionContext) _GitFileDiff_hunks(ctx context.Context, field graphql.CollectedField, obj *repository.FileDiff) (ret graphql.Marshaler) {
1984	fc, err := ec.fieldContext_GitFileDiff_hunks(ctx, field)
1985	if err != nil {
1986		return graphql.Null
1987	}
1988	ctx = graphql.WithFieldContext(ctx, fc)
1989	defer func() {
1990		if r := recover(); r != nil {
1991			ec.Error(ctx, ec.Recover(ctx, r))
1992			ret = graphql.Null
1993		}
1994	}()
1995	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1996		ctx = rctx // use context from middleware stack in children
1997		return obj.Hunks, nil
1998	})
1999	if err != nil {
2000		ec.Error(ctx, err)
2001		return graphql.Null
2002	}
2003	if resTmp == nil {
2004		if !graphql.HasFieldError(ctx, fc) {
2005			ec.Errorf(ctx, "must not be null")
2006		}
2007		return graphql.Null
2008	}
2009	res := resTmp.([]repository.DiffHunk)
2010	fc.Result = res
2011	return ec.marshalNGitDiffHunk2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffHunkᚄ(ctx, field.Selections, res)
2012}
2013
2014func (ec *executionContext) fieldContext_GitFileDiff_hunks(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2015	fc = &graphql.FieldContext{
2016		Object:     "GitFileDiff",
2017		Field:      field,
2018		IsMethod:   false,
2019		IsResolver: false,
2020		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2021			switch field.Name {
2022			case "oldStart":
2023				return ec.fieldContext_GitDiffHunk_oldStart(ctx, field)
2024			case "oldLines":
2025				return ec.fieldContext_GitDiffHunk_oldLines(ctx, field)
2026			case "newStart":
2027				return ec.fieldContext_GitDiffHunk_newStart(ctx, field)
2028			case "newLines":
2029				return ec.fieldContext_GitDiffHunk_newLines(ctx, field)
2030			case "lines":
2031				return ec.fieldContext_GitDiffHunk_lines(ctx, field)
2032			}
2033			return nil, fmt.Errorf("no field named %q was found under type GitDiffHunk", field.Name)
2034		},
2035	}
2036	return fc, nil
2037}
2038
2039func (ec *executionContext) _GitLastCommit_name(ctx context.Context, field graphql.CollectedField, obj *models.GitLastCommit) (ret graphql.Marshaler) {
2040	fc, err := ec.fieldContext_GitLastCommit_name(ctx, field)
2041	if err != nil {
2042		return graphql.Null
2043	}
2044	ctx = graphql.WithFieldContext(ctx, fc)
2045	defer func() {
2046		if r := recover(); r != nil {
2047			ec.Error(ctx, ec.Recover(ctx, r))
2048			ret = graphql.Null
2049		}
2050	}()
2051	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2052		ctx = rctx // use context from middleware stack in children
2053		return obj.Name, nil
2054	})
2055	if err != nil {
2056		ec.Error(ctx, err)
2057		return graphql.Null
2058	}
2059	if resTmp == nil {
2060		if !graphql.HasFieldError(ctx, fc) {
2061			ec.Errorf(ctx, "must not be null")
2062		}
2063		return graphql.Null
2064	}
2065	res := resTmp.(string)
2066	fc.Result = res
2067	return ec.marshalNString2string(ctx, field.Selections, res)
2068}
2069
2070func (ec *executionContext) fieldContext_GitLastCommit_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2071	fc = &graphql.FieldContext{
2072		Object:     "GitLastCommit",
2073		Field:      field,
2074		IsMethod:   false,
2075		IsResolver: false,
2076		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2077			return nil, errors.New("field of type String does not have child fields")
2078		},
2079	}
2080	return fc, nil
2081}
2082
2083func (ec *executionContext) _GitLastCommit_commit(ctx context.Context, field graphql.CollectedField, obj *models.GitLastCommit) (ret graphql.Marshaler) {
2084	fc, err := ec.fieldContext_GitLastCommit_commit(ctx, field)
2085	if err != nil {
2086		return graphql.Null
2087	}
2088	ctx = graphql.WithFieldContext(ctx, fc)
2089	defer func() {
2090		if r := recover(); r != nil {
2091			ec.Error(ctx, ec.Recover(ctx, r))
2092			ret = graphql.Null
2093		}
2094	}()
2095	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2096		ctx = rctx // use context from middleware stack in children
2097		return obj.Commit, nil
2098	})
2099	if err != nil {
2100		ec.Error(ctx, err)
2101		return graphql.Null
2102	}
2103	if resTmp == nil {
2104		if !graphql.HasFieldError(ctx, fc) {
2105			ec.Errorf(ctx, "must not be null")
2106		}
2107		return graphql.Null
2108	}
2109	res := resTmp.(*models.GitCommitMeta)
2110	fc.Result = res
2111	return ec.marshalNGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx, field.Selections, res)
2112}
2113
2114func (ec *executionContext) fieldContext_GitLastCommit_commit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2115	fc = &graphql.FieldContext{
2116		Object:     "GitLastCommit",
2117		Field:      field,
2118		IsMethod:   false,
2119		IsResolver: false,
2120		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2121			switch field.Name {
2122			case "hash":
2123				return ec.fieldContext_GitCommit_hash(ctx, field)
2124			case "shortHash":
2125				return ec.fieldContext_GitCommit_shortHash(ctx, field)
2126			case "message":
2127				return ec.fieldContext_GitCommit_message(ctx, field)
2128			case "fullMessage":
2129				return ec.fieldContext_GitCommit_fullMessage(ctx, field)
2130			case "authorName":
2131				return ec.fieldContext_GitCommit_authorName(ctx, field)
2132			case "authorEmail":
2133				return ec.fieldContext_GitCommit_authorEmail(ctx, field)
2134			case "date":
2135				return ec.fieldContext_GitCommit_date(ctx, field)
2136			case "parents":
2137				return ec.fieldContext_GitCommit_parents(ctx, field)
2138			case "files":
2139				return ec.fieldContext_GitCommit_files(ctx, field)
2140			case "diff":
2141				return ec.fieldContext_GitCommit_diff(ctx, field)
2142			}
2143			return nil, fmt.Errorf("no field named %q was found under type GitCommit", field.Name)
2144		},
2145	}
2146	return fc, nil
2147}
2148
2149func (ec *executionContext) _GitRef_name(ctx context.Context, field graphql.CollectedField, obj *models.GitRef) (ret graphql.Marshaler) {
2150	fc, err := ec.fieldContext_GitRef_name(ctx, field)
2151	if err != nil {
2152		return graphql.Null
2153	}
2154	ctx = graphql.WithFieldContext(ctx, fc)
2155	defer func() {
2156		if r := recover(); r != nil {
2157			ec.Error(ctx, ec.Recover(ctx, r))
2158			ret = graphql.Null
2159		}
2160	}()
2161	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2162		ctx = rctx // use context from middleware stack in children
2163		return obj.Name, nil
2164	})
2165	if err != nil {
2166		ec.Error(ctx, err)
2167		return graphql.Null
2168	}
2169	if resTmp == nil {
2170		if !graphql.HasFieldError(ctx, fc) {
2171			ec.Errorf(ctx, "must not be null")
2172		}
2173		return graphql.Null
2174	}
2175	res := resTmp.(string)
2176	fc.Result = res
2177	return ec.marshalNString2string(ctx, field.Selections, res)
2178}
2179
2180func (ec *executionContext) fieldContext_GitRef_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2181	fc = &graphql.FieldContext{
2182		Object:     "GitRef",
2183		Field:      field,
2184		IsMethod:   false,
2185		IsResolver: false,
2186		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2187			return nil, errors.New("field of type String does not have child fields")
2188		},
2189	}
2190	return fc, nil
2191}
2192
2193func (ec *executionContext) _GitRef_shortName(ctx context.Context, field graphql.CollectedField, obj *models.GitRef) (ret graphql.Marshaler) {
2194	fc, err := ec.fieldContext_GitRef_shortName(ctx, field)
2195	if err != nil {
2196		return graphql.Null
2197	}
2198	ctx = graphql.WithFieldContext(ctx, fc)
2199	defer func() {
2200		if r := recover(); r != nil {
2201			ec.Error(ctx, ec.Recover(ctx, r))
2202			ret = graphql.Null
2203		}
2204	}()
2205	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2206		ctx = rctx // use context from middleware stack in children
2207		return obj.ShortName, nil
2208	})
2209	if err != nil {
2210		ec.Error(ctx, err)
2211		return graphql.Null
2212	}
2213	if resTmp == nil {
2214		if !graphql.HasFieldError(ctx, fc) {
2215			ec.Errorf(ctx, "must not be null")
2216		}
2217		return graphql.Null
2218	}
2219	res := resTmp.(string)
2220	fc.Result = res
2221	return ec.marshalNString2string(ctx, field.Selections, res)
2222}
2223
2224func (ec *executionContext) fieldContext_GitRef_shortName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2225	fc = &graphql.FieldContext{
2226		Object:     "GitRef",
2227		Field:      field,
2228		IsMethod:   false,
2229		IsResolver: false,
2230		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2231			return nil, errors.New("field of type String does not have child fields")
2232		},
2233	}
2234	return fc, nil
2235}
2236
2237func (ec *executionContext) _GitRef_type(ctx context.Context, field graphql.CollectedField, obj *models.GitRef) (ret graphql.Marshaler) {
2238	fc, err := ec.fieldContext_GitRef_type(ctx, field)
2239	if err != nil {
2240		return graphql.Null
2241	}
2242	ctx = graphql.WithFieldContext(ctx, fc)
2243	defer func() {
2244		if r := recover(); r != nil {
2245			ec.Error(ctx, ec.Recover(ctx, r))
2246			ret = graphql.Null
2247		}
2248	}()
2249	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2250		ctx = rctx // use context from middleware stack in children
2251		return obj.Type, nil
2252	})
2253	if err != nil {
2254		ec.Error(ctx, err)
2255		return graphql.Null
2256	}
2257	if resTmp == nil {
2258		if !graphql.HasFieldError(ctx, fc) {
2259			ec.Errorf(ctx, "must not be null")
2260		}
2261		return graphql.Null
2262	}
2263	res := resTmp.(repository.GitRefType)
2264	fc.Result = res
2265	return ec.marshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType(ctx, field.Selections, res)
2266}
2267
2268func (ec *executionContext) fieldContext_GitRef_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2269	fc = &graphql.FieldContext{
2270		Object:     "GitRef",
2271		Field:      field,
2272		IsMethod:   false,
2273		IsResolver: false,
2274		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2275			return nil, errors.New("field of type GitRefType does not have child fields")
2276		},
2277	}
2278	return fc, nil
2279}
2280
2281func (ec *executionContext) _GitRef_hash(ctx context.Context, field graphql.CollectedField, obj *models.GitRef) (ret graphql.Marshaler) {
2282	fc, err := ec.fieldContext_GitRef_hash(ctx, field)
2283	if err != nil {
2284		return graphql.Null
2285	}
2286	ctx = graphql.WithFieldContext(ctx, fc)
2287	defer func() {
2288		if r := recover(); r != nil {
2289			ec.Error(ctx, ec.Recover(ctx, r))
2290			ret = graphql.Null
2291		}
2292	}()
2293	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2294		ctx = rctx // use context from middleware stack in children
2295		return obj.Hash, nil
2296	})
2297	if err != nil {
2298		ec.Error(ctx, err)
2299		return graphql.Null
2300	}
2301	if resTmp == nil {
2302		if !graphql.HasFieldError(ctx, fc) {
2303			ec.Errorf(ctx, "must not be null")
2304		}
2305		return graphql.Null
2306	}
2307	res := resTmp.(string)
2308	fc.Result = res
2309	return ec.marshalNString2string(ctx, field.Selections, res)
2310}
2311
2312func (ec *executionContext) fieldContext_GitRef_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2313	fc = &graphql.FieldContext{
2314		Object:     "GitRef",
2315		Field:      field,
2316		IsMethod:   false,
2317		IsResolver: false,
2318		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2319			return nil, errors.New("field of type String does not have child fields")
2320		},
2321	}
2322	return fc, nil
2323}
2324
2325func (ec *executionContext) _GitRef_commit(ctx context.Context, field graphql.CollectedField, obj *models.GitRef) (ret graphql.Marshaler) {
2326	fc, err := ec.fieldContext_GitRef_commit(ctx, field)
2327	if err != nil {
2328		return graphql.Null
2329	}
2330	ctx = graphql.WithFieldContext(ctx, fc)
2331	defer func() {
2332		if r := recover(); r != nil {
2333			ec.Error(ctx, ec.Recover(ctx, r))
2334			ret = graphql.Null
2335		}
2336	}()
2337	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2338		ctx = rctx // use context from middleware stack in children
2339		return ec.resolvers.GitRef().Commit(rctx, obj)
2340	})
2341	if err != nil {
2342		ec.Error(ctx, err)
2343		return graphql.Null
2344	}
2345	if resTmp == nil {
2346		if !graphql.HasFieldError(ctx, fc) {
2347			ec.Errorf(ctx, "must not be null")
2348		}
2349		return graphql.Null
2350	}
2351	res := resTmp.(*models.GitCommitMeta)
2352	fc.Result = res
2353	return ec.marshalNGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx, field.Selections, res)
2354}
2355
2356func (ec *executionContext) fieldContext_GitRef_commit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2357	fc = &graphql.FieldContext{
2358		Object:     "GitRef",
2359		Field:      field,
2360		IsMethod:   true,
2361		IsResolver: true,
2362		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2363			switch field.Name {
2364			case "hash":
2365				return ec.fieldContext_GitCommit_hash(ctx, field)
2366			case "shortHash":
2367				return ec.fieldContext_GitCommit_shortHash(ctx, field)
2368			case "message":
2369				return ec.fieldContext_GitCommit_message(ctx, field)
2370			case "fullMessage":
2371				return ec.fieldContext_GitCommit_fullMessage(ctx, field)
2372			case "authorName":
2373				return ec.fieldContext_GitCommit_authorName(ctx, field)
2374			case "authorEmail":
2375				return ec.fieldContext_GitCommit_authorEmail(ctx, field)
2376			case "date":
2377				return ec.fieldContext_GitCommit_date(ctx, field)
2378			case "parents":
2379				return ec.fieldContext_GitCommit_parents(ctx, field)
2380			case "files":
2381				return ec.fieldContext_GitCommit_files(ctx, field)
2382			case "diff":
2383				return ec.fieldContext_GitCommit_diff(ctx, field)
2384			}
2385			return nil, fmt.Errorf("no field named %q was found under type GitCommit", field.Name)
2386		},
2387	}
2388	return fc, nil
2389}
2390
2391func (ec *executionContext) _GitRefConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.GitRefConnection) (ret graphql.Marshaler) {
2392	fc, err := ec.fieldContext_GitRefConnection_nodes(ctx, field)
2393	if err != nil {
2394		return graphql.Null
2395	}
2396	ctx = graphql.WithFieldContext(ctx, fc)
2397	defer func() {
2398		if r := recover(); r != nil {
2399			ec.Error(ctx, ec.Recover(ctx, r))
2400			ret = graphql.Null
2401		}
2402	}()
2403	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2404		ctx = rctx // use context from middleware stack in children
2405		return obj.Nodes, nil
2406	})
2407	if err != nil {
2408		ec.Error(ctx, err)
2409		return graphql.Null
2410	}
2411	if resTmp == nil {
2412		if !graphql.HasFieldError(ctx, fc) {
2413			ec.Errorf(ctx, "must not be null")
2414		}
2415		return graphql.Null
2416	}
2417	res := resTmp.([]*models.GitRef)
2418	fc.Result = res
2419	return ec.marshalNGitRef2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefᚄ(ctx, field.Selections, res)
2420}
2421
2422func (ec *executionContext) fieldContext_GitRefConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2423	fc = &graphql.FieldContext{
2424		Object:     "GitRefConnection",
2425		Field:      field,
2426		IsMethod:   false,
2427		IsResolver: false,
2428		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2429			switch field.Name {
2430			case "name":
2431				return ec.fieldContext_GitRef_name(ctx, field)
2432			case "shortName":
2433				return ec.fieldContext_GitRef_shortName(ctx, field)
2434			case "type":
2435				return ec.fieldContext_GitRef_type(ctx, field)
2436			case "hash":
2437				return ec.fieldContext_GitRef_hash(ctx, field)
2438			case "commit":
2439				return ec.fieldContext_GitRef_commit(ctx, field)
2440			}
2441			return nil, fmt.Errorf("no field named %q was found under type GitRef", field.Name)
2442		},
2443	}
2444	return fc, nil
2445}
2446
2447func (ec *executionContext) _GitRefConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.GitRefConnection) (ret graphql.Marshaler) {
2448	fc, err := ec.fieldContext_GitRefConnection_pageInfo(ctx, field)
2449	if err != nil {
2450		return graphql.Null
2451	}
2452	ctx = graphql.WithFieldContext(ctx, fc)
2453	defer func() {
2454		if r := recover(); r != nil {
2455			ec.Error(ctx, ec.Recover(ctx, r))
2456			ret = graphql.Null
2457		}
2458	}()
2459	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2460		ctx = rctx // use context from middleware stack in children
2461		return obj.PageInfo, nil
2462	})
2463	if err != nil {
2464		ec.Error(ctx, err)
2465		return graphql.Null
2466	}
2467	if resTmp == nil {
2468		if !graphql.HasFieldError(ctx, fc) {
2469			ec.Errorf(ctx, "must not be null")
2470		}
2471		return graphql.Null
2472	}
2473	res := resTmp.(*models.PageInfo)
2474	fc.Result = res
2475	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
2476}
2477
2478func (ec *executionContext) fieldContext_GitRefConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2479	fc = &graphql.FieldContext{
2480		Object:     "GitRefConnection",
2481		Field:      field,
2482		IsMethod:   false,
2483		IsResolver: false,
2484		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2485			switch field.Name {
2486			case "hasNextPage":
2487				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
2488			case "hasPreviousPage":
2489				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
2490			case "startCursor":
2491				return ec.fieldContext_PageInfo_startCursor(ctx, field)
2492			case "endCursor":
2493				return ec.fieldContext_PageInfo_endCursor(ctx, field)
2494			}
2495			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
2496		},
2497	}
2498	return fc, nil
2499}
2500
2501func (ec *executionContext) _GitRefConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.GitRefConnection) (ret graphql.Marshaler) {
2502	fc, err := ec.fieldContext_GitRefConnection_totalCount(ctx, field)
2503	if err != nil {
2504		return graphql.Null
2505	}
2506	ctx = graphql.WithFieldContext(ctx, fc)
2507	defer func() {
2508		if r := recover(); r != nil {
2509			ec.Error(ctx, ec.Recover(ctx, r))
2510			ret = graphql.Null
2511		}
2512	}()
2513	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2514		ctx = rctx // use context from middleware stack in children
2515		return obj.TotalCount, nil
2516	})
2517	if err != nil {
2518		ec.Error(ctx, err)
2519		return graphql.Null
2520	}
2521	if resTmp == nil {
2522		if !graphql.HasFieldError(ctx, fc) {
2523			ec.Errorf(ctx, "must not be null")
2524		}
2525		return graphql.Null
2526	}
2527	res := resTmp.(int)
2528	fc.Result = res
2529	return ec.marshalNInt2int(ctx, field.Selections, res)
2530}
2531
2532func (ec *executionContext) fieldContext_GitRefConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2533	fc = &graphql.FieldContext{
2534		Object:     "GitRefConnection",
2535		Field:      field,
2536		IsMethod:   false,
2537		IsResolver: false,
2538		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2539			return nil, errors.New("field of type Int does not have child fields")
2540		},
2541	}
2542	return fc, nil
2543}
2544
2545func (ec *executionContext) _GitTreeEntry_name(ctx context.Context, field graphql.CollectedField, obj *models.GitTreeEntry) (ret graphql.Marshaler) {
2546	fc, err := ec.fieldContext_GitTreeEntry_name(ctx, field)
2547	if err != nil {
2548		return graphql.Null
2549	}
2550	ctx = graphql.WithFieldContext(ctx, fc)
2551	defer func() {
2552		if r := recover(); r != nil {
2553			ec.Error(ctx, ec.Recover(ctx, r))
2554			ret = graphql.Null
2555		}
2556	}()
2557	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2558		ctx = rctx // use context from middleware stack in children
2559		return obj.Name, nil
2560	})
2561	if err != nil {
2562		ec.Error(ctx, err)
2563		return graphql.Null
2564	}
2565	if resTmp == nil {
2566		if !graphql.HasFieldError(ctx, fc) {
2567			ec.Errorf(ctx, "must not be null")
2568		}
2569		return graphql.Null
2570	}
2571	res := resTmp.(string)
2572	fc.Result = res
2573	return ec.marshalNString2string(ctx, field.Selections, res)
2574}
2575
2576func (ec *executionContext) fieldContext_GitTreeEntry_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2577	fc = &graphql.FieldContext{
2578		Object:     "GitTreeEntry",
2579		Field:      field,
2580		IsMethod:   false,
2581		IsResolver: false,
2582		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2583			return nil, errors.New("field of type String does not have child fields")
2584		},
2585	}
2586	return fc, nil
2587}
2588
2589func (ec *executionContext) _GitTreeEntry_type(ctx context.Context, field graphql.CollectedField, obj *models.GitTreeEntry) (ret graphql.Marshaler) {
2590	fc, err := ec.fieldContext_GitTreeEntry_type(ctx, field)
2591	if err != nil {
2592		return graphql.Null
2593	}
2594	ctx = graphql.WithFieldContext(ctx, fc)
2595	defer func() {
2596		if r := recover(); r != nil {
2597			ec.Error(ctx, ec.Recover(ctx, r))
2598			ret = graphql.Null
2599		}
2600	}()
2601	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2602		ctx = rctx // use context from middleware stack in children
2603		return obj.ObjectType, nil
2604	})
2605	if err != nil {
2606		ec.Error(ctx, err)
2607		return graphql.Null
2608	}
2609	if resTmp == nil {
2610		if !graphql.HasFieldError(ctx, fc) {
2611			ec.Errorf(ctx, "must not be null")
2612		}
2613		return graphql.Null
2614	}
2615	res := resTmp.(repository.ObjectType)
2616	fc.Result = res
2617	return ec.marshalNGitObjectType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐObjectType(ctx, field.Selections, res)
2618}
2619
2620func (ec *executionContext) fieldContext_GitTreeEntry_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2621	fc = &graphql.FieldContext{
2622		Object:     "GitTreeEntry",
2623		Field:      field,
2624		IsMethod:   false,
2625		IsResolver: false,
2626		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2627			return nil, errors.New("field of type GitObjectType does not have child fields")
2628		},
2629	}
2630	return fc, nil
2631}
2632
2633func (ec *executionContext) _GitTreeEntry_hash(ctx context.Context, field graphql.CollectedField, obj *models.GitTreeEntry) (ret graphql.Marshaler) {
2634	fc, err := ec.fieldContext_GitTreeEntry_hash(ctx, field)
2635	if err != nil {
2636		return graphql.Null
2637	}
2638	ctx = graphql.WithFieldContext(ctx, fc)
2639	defer func() {
2640		if r := recover(); r != nil {
2641			ec.Error(ctx, ec.Recover(ctx, r))
2642			ret = graphql.Null
2643		}
2644	}()
2645	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2646		ctx = rctx // use context from middleware stack in children
2647		return obj.Hash, nil
2648	})
2649	if err != nil {
2650		ec.Error(ctx, err)
2651		return graphql.Null
2652	}
2653	if resTmp == nil {
2654		if !graphql.HasFieldError(ctx, fc) {
2655			ec.Errorf(ctx, "must not be null")
2656		}
2657		return graphql.Null
2658	}
2659	res := resTmp.(repository.Hash)
2660	fc.Result = res
2661	return ec.marshalNString2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHash(ctx, field.Selections, res)
2662}
2663
2664func (ec *executionContext) fieldContext_GitTreeEntry_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2665	fc = &graphql.FieldContext{
2666		Object:     "GitTreeEntry",
2667		Field:      field,
2668		IsMethod:   false,
2669		IsResolver: false,
2670		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2671			return nil, errors.New("field of type String does not have child fields")
2672		},
2673	}
2674	return fc, nil
2675}
2676
2677func (ec *executionContext) _GitTreeEntry_lastCommit(ctx context.Context, field graphql.CollectedField, obj *models.GitTreeEntry) (ret graphql.Marshaler) {
2678	fc, err := ec.fieldContext_GitTreeEntry_lastCommit(ctx, field)
2679	if err != nil {
2680		return graphql.Null
2681	}
2682	ctx = graphql.WithFieldContext(ctx, fc)
2683	defer func() {
2684		if r := recover(); r != nil {
2685			ec.Error(ctx, ec.Recover(ctx, r))
2686			ret = graphql.Null
2687		}
2688	}()
2689	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
2690		ctx = rctx // use context from middleware stack in children
2691		return ec.resolvers.GitTreeEntry().LastCommit(rctx, obj)
2692	})
2693	if err != nil {
2694		ec.Error(ctx, err)
2695		return graphql.Null
2696	}
2697	if resTmp == nil {
2698		return graphql.Null
2699	}
2700	res := resTmp.(*models.GitCommitMeta)
2701	fc.Result = res
2702	return ec.marshalOGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx, field.Selections, res)
2703}
2704
2705func (ec *executionContext) fieldContext_GitTreeEntry_lastCommit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2706	fc = &graphql.FieldContext{
2707		Object:     "GitTreeEntry",
2708		Field:      field,
2709		IsMethod:   true,
2710		IsResolver: true,
2711		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2712			switch field.Name {
2713			case "hash":
2714				return ec.fieldContext_GitCommit_hash(ctx, field)
2715			case "shortHash":
2716				return ec.fieldContext_GitCommit_shortHash(ctx, field)
2717			case "message":
2718				return ec.fieldContext_GitCommit_message(ctx, field)
2719			case "fullMessage":
2720				return ec.fieldContext_GitCommit_fullMessage(ctx, field)
2721			case "authorName":
2722				return ec.fieldContext_GitCommit_authorName(ctx, field)
2723			case "authorEmail":
2724				return ec.fieldContext_GitCommit_authorEmail(ctx, field)
2725			case "date":
2726				return ec.fieldContext_GitCommit_date(ctx, field)
2727			case "parents":
2728				return ec.fieldContext_GitCommit_parents(ctx, field)
2729			case "files":
2730				return ec.fieldContext_GitCommit_files(ctx, field)
2731			case "diff":
2732				return ec.fieldContext_GitCommit_diff(ctx, field)
2733			}
2734			return nil, fmt.Errorf("no field named %q was found under type GitCommit", field.Name)
2735		},
2736	}
2737	return fc, nil
2738}
2739
2740// endregion **************************** field.gotpl *****************************
2741
2742// region    **************************** input.gotpl *****************************
2743
2744// endregion **************************** input.gotpl *****************************
2745
2746// region    ************************** interface.gotpl ***************************
2747
2748// endregion ************************** interface.gotpl ***************************
2749
2750// region    **************************** object.gotpl ****************************
2751
2752var gitBlobImplementors = []string{"GitBlob"}
2753
2754func (ec *executionContext) _GitBlob(ctx context.Context, sel ast.SelectionSet, obj *models.GitBlob) graphql.Marshaler {
2755	fields := graphql.CollectFields(ec.OperationContext, sel, gitBlobImplementors)
2756
2757	out := graphql.NewFieldSet(fields)
2758	deferred := make(map[string]*graphql.FieldSet)
2759	for i, field := range fields {
2760		switch field.Name {
2761		case "__typename":
2762			out.Values[i] = graphql.MarshalString("GitBlob")
2763		case "path":
2764			out.Values[i] = ec._GitBlob_path(ctx, field, obj)
2765			if out.Values[i] == graphql.Null {
2766				out.Invalids++
2767			}
2768		case "hash":
2769			out.Values[i] = ec._GitBlob_hash(ctx, field, obj)
2770			if out.Values[i] == graphql.Null {
2771				out.Invalids++
2772			}
2773		case "text":
2774			out.Values[i] = ec._GitBlob_text(ctx, field, obj)
2775		case "size":
2776			out.Values[i] = ec._GitBlob_size(ctx, field, obj)
2777			if out.Values[i] == graphql.Null {
2778				out.Invalids++
2779			}
2780		case "isBinary":
2781			out.Values[i] = ec._GitBlob_isBinary(ctx, field, obj)
2782			if out.Values[i] == graphql.Null {
2783				out.Invalids++
2784			}
2785		case "isTruncated":
2786			out.Values[i] = ec._GitBlob_isTruncated(ctx, field, obj)
2787			if out.Values[i] == graphql.Null {
2788				out.Invalids++
2789			}
2790		default:
2791			panic("unknown field " + strconv.Quote(field.Name))
2792		}
2793	}
2794	out.Dispatch(ctx)
2795	if out.Invalids > 0 {
2796		return graphql.Null
2797	}
2798
2799	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2800
2801	for label, dfs := range deferred {
2802		ec.processDeferredGroup(graphql.DeferredGroup{
2803			Label:    label,
2804			Path:     graphql.GetPath(ctx),
2805			FieldSet: dfs,
2806			Context:  ctx,
2807		})
2808	}
2809
2810	return out
2811}
2812
2813var gitChangedFileImplementors = []string{"GitChangedFile"}
2814
2815func (ec *executionContext) _GitChangedFile(ctx context.Context, sel ast.SelectionSet, obj *repository.ChangedFile) graphql.Marshaler {
2816	fields := graphql.CollectFields(ec.OperationContext, sel, gitChangedFileImplementors)
2817
2818	out := graphql.NewFieldSet(fields)
2819	deferred := make(map[string]*graphql.FieldSet)
2820	for i, field := range fields {
2821		switch field.Name {
2822		case "__typename":
2823			out.Values[i] = graphql.MarshalString("GitChangedFile")
2824		case "path":
2825			out.Values[i] = ec._GitChangedFile_path(ctx, field, obj)
2826			if out.Values[i] == graphql.Null {
2827				out.Invalids++
2828			}
2829		case "oldPath":
2830			out.Values[i] = ec._GitChangedFile_oldPath(ctx, field, obj)
2831		case "status":
2832			out.Values[i] = ec._GitChangedFile_status(ctx, field, obj)
2833			if out.Values[i] == graphql.Null {
2834				out.Invalids++
2835			}
2836		default:
2837			panic("unknown field " + strconv.Quote(field.Name))
2838		}
2839	}
2840	out.Dispatch(ctx)
2841	if out.Invalids > 0 {
2842		return graphql.Null
2843	}
2844
2845	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2846
2847	for label, dfs := range deferred {
2848		ec.processDeferredGroup(graphql.DeferredGroup{
2849			Label:    label,
2850			Path:     graphql.GetPath(ctx),
2851			FieldSet: dfs,
2852			Context:  ctx,
2853		})
2854	}
2855
2856	return out
2857}
2858
2859var gitChangedFileConnectionImplementors = []string{"GitChangedFileConnection"}
2860
2861func (ec *executionContext) _GitChangedFileConnection(ctx context.Context, sel ast.SelectionSet, obj *models.GitChangedFileConnection) graphql.Marshaler {
2862	fields := graphql.CollectFields(ec.OperationContext, sel, gitChangedFileConnectionImplementors)
2863
2864	out := graphql.NewFieldSet(fields)
2865	deferred := make(map[string]*graphql.FieldSet)
2866	for i, field := range fields {
2867		switch field.Name {
2868		case "__typename":
2869			out.Values[i] = graphql.MarshalString("GitChangedFileConnection")
2870		case "nodes":
2871			out.Values[i] = ec._GitChangedFileConnection_nodes(ctx, field, obj)
2872			if out.Values[i] == graphql.Null {
2873				out.Invalids++
2874			}
2875		case "pageInfo":
2876			out.Values[i] = ec._GitChangedFileConnection_pageInfo(ctx, field, obj)
2877			if out.Values[i] == graphql.Null {
2878				out.Invalids++
2879			}
2880		case "totalCount":
2881			out.Values[i] = ec._GitChangedFileConnection_totalCount(ctx, field, obj)
2882			if out.Values[i] == graphql.Null {
2883				out.Invalids++
2884			}
2885		default:
2886			panic("unknown field " + strconv.Quote(field.Name))
2887		}
2888	}
2889	out.Dispatch(ctx)
2890	if out.Invalids > 0 {
2891		return graphql.Null
2892	}
2893
2894	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2895
2896	for label, dfs := range deferred {
2897		ec.processDeferredGroup(graphql.DeferredGroup{
2898			Label:    label,
2899			Path:     graphql.GetPath(ctx),
2900			FieldSet: dfs,
2901			Context:  ctx,
2902		})
2903	}
2904
2905	return out
2906}
2907
2908var gitCommitImplementors = []string{"GitCommit"}
2909
2910func (ec *executionContext) _GitCommit(ctx context.Context, sel ast.SelectionSet, obj *models.GitCommitMeta) graphql.Marshaler {
2911	fields := graphql.CollectFields(ec.OperationContext, sel, gitCommitImplementors)
2912
2913	out := graphql.NewFieldSet(fields)
2914	deferred := make(map[string]*graphql.FieldSet)
2915	for i, field := range fields {
2916		switch field.Name {
2917		case "__typename":
2918			out.Values[i] = graphql.MarshalString("GitCommit")
2919		case "hash":
2920			out.Values[i] = ec._GitCommit_hash(ctx, field, obj)
2921			if out.Values[i] == graphql.Null {
2922				atomic.AddUint32(&out.Invalids, 1)
2923			}
2924		case "shortHash":
2925			field := field
2926
2927			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2928				defer func() {
2929					if r := recover(); r != nil {
2930						ec.Error(ctx, ec.Recover(ctx, r))
2931					}
2932				}()
2933				res = ec._GitCommit_shortHash(ctx, field, obj)
2934				if res == graphql.Null {
2935					atomic.AddUint32(&fs.Invalids, 1)
2936				}
2937				return res
2938			}
2939
2940			if field.Deferrable != nil {
2941				dfs, ok := deferred[field.Deferrable.Label]
2942				di := 0
2943				if ok {
2944					dfs.AddField(field)
2945					di = len(dfs.Values) - 1
2946				} else {
2947					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2948					deferred[field.Deferrable.Label] = dfs
2949				}
2950				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2951					return innerFunc(ctx, dfs)
2952				})
2953
2954				// don't run the out.Concurrently() call below
2955				out.Values[i] = graphql.Null
2956				continue
2957			}
2958
2959			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2960		case "message":
2961			out.Values[i] = ec._GitCommit_message(ctx, field, obj)
2962			if out.Values[i] == graphql.Null {
2963				atomic.AddUint32(&out.Invalids, 1)
2964			}
2965		case "fullMessage":
2966			field := field
2967
2968			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2969				defer func() {
2970					if r := recover(); r != nil {
2971						ec.Error(ctx, ec.Recover(ctx, r))
2972					}
2973				}()
2974				res = ec._GitCommit_fullMessage(ctx, field, obj)
2975				if res == graphql.Null {
2976					atomic.AddUint32(&fs.Invalids, 1)
2977				}
2978				return res
2979			}
2980
2981			if field.Deferrable != nil {
2982				dfs, ok := deferred[field.Deferrable.Label]
2983				di := 0
2984				if ok {
2985					dfs.AddField(field)
2986					di = len(dfs.Values) - 1
2987				} else {
2988					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2989					deferred[field.Deferrable.Label] = dfs
2990				}
2991				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2992					return innerFunc(ctx, dfs)
2993				})
2994
2995				// don't run the out.Concurrently() call below
2996				out.Values[i] = graphql.Null
2997				continue
2998			}
2999
3000			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3001		case "authorName":
3002			out.Values[i] = ec._GitCommit_authorName(ctx, field, obj)
3003			if out.Values[i] == graphql.Null {
3004				atomic.AddUint32(&out.Invalids, 1)
3005			}
3006		case "authorEmail":
3007			out.Values[i] = ec._GitCommit_authorEmail(ctx, field, obj)
3008			if out.Values[i] == graphql.Null {
3009				atomic.AddUint32(&out.Invalids, 1)
3010			}
3011		case "date":
3012			out.Values[i] = ec._GitCommit_date(ctx, field, obj)
3013			if out.Values[i] == graphql.Null {
3014				atomic.AddUint32(&out.Invalids, 1)
3015			}
3016		case "parents":
3017			field := field
3018
3019			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
3020				defer func() {
3021					if r := recover(); r != nil {
3022						ec.Error(ctx, ec.Recover(ctx, r))
3023					}
3024				}()
3025				res = ec._GitCommit_parents(ctx, field, obj)
3026				if res == graphql.Null {
3027					atomic.AddUint32(&fs.Invalids, 1)
3028				}
3029				return res
3030			}
3031
3032			if field.Deferrable != nil {
3033				dfs, ok := deferred[field.Deferrable.Label]
3034				di := 0
3035				if ok {
3036					dfs.AddField(field)
3037					di = len(dfs.Values) - 1
3038				} else {
3039					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
3040					deferred[field.Deferrable.Label] = dfs
3041				}
3042				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
3043					return innerFunc(ctx, dfs)
3044				})
3045
3046				// don't run the out.Concurrently() call below
3047				out.Values[i] = graphql.Null
3048				continue
3049			}
3050
3051			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3052		case "files":
3053			field := field
3054
3055			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
3056				defer func() {
3057					if r := recover(); r != nil {
3058						ec.Error(ctx, ec.Recover(ctx, r))
3059					}
3060				}()
3061				res = ec._GitCommit_files(ctx, field, obj)
3062				if res == graphql.Null {
3063					atomic.AddUint32(&fs.Invalids, 1)
3064				}
3065				return res
3066			}
3067
3068			if field.Deferrable != nil {
3069				dfs, ok := deferred[field.Deferrable.Label]
3070				di := 0
3071				if ok {
3072					dfs.AddField(field)
3073					di = len(dfs.Values) - 1
3074				} else {
3075					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
3076					deferred[field.Deferrable.Label] = dfs
3077				}
3078				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
3079					return innerFunc(ctx, dfs)
3080				})
3081
3082				// don't run the out.Concurrently() call below
3083				out.Values[i] = graphql.Null
3084				continue
3085			}
3086
3087			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3088		case "diff":
3089			field := field
3090
3091			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
3092				defer func() {
3093					if r := recover(); r != nil {
3094						ec.Error(ctx, ec.Recover(ctx, r))
3095					}
3096				}()
3097				res = ec._GitCommit_diff(ctx, field, obj)
3098				return res
3099			}
3100
3101			if field.Deferrable != nil {
3102				dfs, ok := deferred[field.Deferrable.Label]
3103				di := 0
3104				if ok {
3105					dfs.AddField(field)
3106					di = len(dfs.Values) - 1
3107				} else {
3108					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
3109					deferred[field.Deferrable.Label] = dfs
3110				}
3111				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
3112					return innerFunc(ctx, dfs)
3113				})
3114
3115				// don't run the out.Concurrently() call below
3116				out.Values[i] = graphql.Null
3117				continue
3118			}
3119
3120			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3121		default:
3122			panic("unknown field " + strconv.Quote(field.Name))
3123		}
3124	}
3125	out.Dispatch(ctx)
3126	if out.Invalids > 0 {
3127		return graphql.Null
3128	}
3129
3130	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3131
3132	for label, dfs := range deferred {
3133		ec.processDeferredGroup(graphql.DeferredGroup{
3134			Label:    label,
3135			Path:     graphql.GetPath(ctx),
3136			FieldSet: dfs,
3137			Context:  ctx,
3138		})
3139	}
3140
3141	return out
3142}
3143
3144var gitCommitConnectionImplementors = []string{"GitCommitConnection"}
3145
3146func (ec *executionContext) _GitCommitConnection(ctx context.Context, sel ast.SelectionSet, obj *models.GitCommitConnection) graphql.Marshaler {
3147	fields := graphql.CollectFields(ec.OperationContext, sel, gitCommitConnectionImplementors)
3148
3149	out := graphql.NewFieldSet(fields)
3150	deferred := make(map[string]*graphql.FieldSet)
3151	for i, field := range fields {
3152		switch field.Name {
3153		case "__typename":
3154			out.Values[i] = graphql.MarshalString("GitCommitConnection")
3155		case "nodes":
3156			out.Values[i] = ec._GitCommitConnection_nodes(ctx, field, obj)
3157			if out.Values[i] == graphql.Null {
3158				out.Invalids++
3159			}
3160		case "pageInfo":
3161			out.Values[i] = ec._GitCommitConnection_pageInfo(ctx, field, obj)
3162			if out.Values[i] == graphql.Null {
3163				out.Invalids++
3164			}
3165		case "totalCount":
3166			out.Values[i] = ec._GitCommitConnection_totalCount(ctx, field, obj)
3167			if out.Values[i] == graphql.Null {
3168				out.Invalids++
3169			}
3170		default:
3171			panic("unknown field " + strconv.Quote(field.Name))
3172		}
3173	}
3174	out.Dispatch(ctx)
3175	if out.Invalids > 0 {
3176		return graphql.Null
3177	}
3178
3179	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3180
3181	for label, dfs := range deferred {
3182		ec.processDeferredGroup(graphql.DeferredGroup{
3183			Label:    label,
3184			Path:     graphql.GetPath(ctx),
3185			FieldSet: dfs,
3186			Context:  ctx,
3187		})
3188	}
3189
3190	return out
3191}
3192
3193var gitDiffHunkImplementors = []string{"GitDiffHunk"}
3194
3195func (ec *executionContext) _GitDiffHunk(ctx context.Context, sel ast.SelectionSet, obj *repository.DiffHunk) graphql.Marshaler {
3196	fields := graphql.CollectFields(ec.OperationContext, sel, gitDiffHunkImplementors)
3197
3198	out := graphql.NewFieldSet(fields)
3199	deferred := make(map[string]*graphql.FieldSet)
3200	for i, field := range fields {
3201		switch field.Name {
3202		case "__typename":
3203			out.Values[i] = graphql.MarshalString("GitDiffHunk")
3204		case "oldStart":
3205			out.Values[i] = ec._GitDiffHunk_oldStart(ctx, field, obj)
3206			if out.Values[i] == graphql.Null {
3207				out.Invalids++
3208			}
3209		case "oldLines":
3210			out.Values[i] = ec._GitDiffHunk_oldLines(ctx, field, obj)
3211			if out.Values[i] == graphql.Null {
3212				out.Invalids++
3213			}
3214		case "newStart":
3215			out.Values[i] = ec._GitDiffHunk_newStart(ctx, field, obj)
3216			if out.Values[i] == graphql.Null {
3217				out.Invalids++
3218			}
3219		case "newLines":
3220			out.Values[i] = ec._GitDiffHunk_newLines(ctx, field, obj)
3221			if out.Values[i] == graphql.Null {
3222				out.Invalids++
3223			}
3224		case "lines":
3225			out.Values[i] = ec._GitDiffHunk_lines(ctx, field, obj)
3226			if out.Values[i] == graphql.Null {
3227				out.Invalids++
3228			}
3229		default:
3230			panic("unknown field " + strconv.Quote(field.Name))
3231		}
3232	}
3233	out.Dispatch(ctx)
3234	if out.Invalids > 0 {
3235		return graphql.Null
3236	}
3237
3238	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3239
3240	for label, dfs := range deferred {
3241		ec.processDeferredGroup(graphql.DeferredGroup{
3242			Label:    label,
3243			Path:     graphql.GetPath(ctx),
3244			FieldSet: dfs,
3245			Context:  ctx,
3246		})
3247	}
3248
3249	return out
3250}
3251
3252var gitDiffLineImplementors = []string{"GitDiffLine"}
3253
3254func (ec *executionContext) _GitDiffLine(ctx context.Context, sel ast.SelectionSet, obj *repository.DiffLine) graphql.Marshaler {
3255	fields := graphql.CollectFields(ec.OperationContext, sel, gitDiffLineImplementors)
3256
3257	out := graphql.NewFieldSet(fields)
3258	deferred := make(map[string]*graphql.FieldSet)
3259	for i, field := range fields {
3260		switch field.Name {
3261		case "__typename":
3262			out.Values[i] = graphql.MarshalString("GitDiffLine")
3263		case "type":
3264			out.Values[i] = ec._GitDiffLine_type(ctx, field, obj)
3265			if out.Values[i] == graphql.Null {
3266				out.Invalids++
3267			}
3268		case "content":
3269			out.Values[i] = ec._GitDiffLine_content(ctx, field, obj)
3270			if out.Values[i] == graphql.Null {
3271				out.Invalids++
3272			}
3273		case "oldLine":
3274			out.Values[i] = ec._GitDiffLine_oldLine(ctx, field, obj)
3275			if out.Values[i] == graphql.Null {
3276				out.Invalids++
3277			}
3278		case "newLine":
3279			out.Values[i] = ec._GitDiffLine_newLine(ctx, field, obj)
3280			if out.Values[i] == graphql.Null {
3281				out.Invalids++
3282			}
3283		default:
3284			panic("unknown field " + strconv.Quote(field.Name))
3285		}
3286	}
3287	out.Dispatch(ctx)
3288	if out.Invalids > 0 {
3289		return graphql.Null
3290	}
3291
3292	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3293
3294	for label, dfs := range deferred {
3295		ec.processDeferredGroup(graphql.DeferredGroup{
3296			Label:    label,
3297			Path:     graphql.GetPath(ctx),
3298			FieldSet: dfs,
3299			Context:  ctx,
3300		})
3301	}
3302
3303	return out
3304}
3305
3306var gitFileDiffImplementors = []string{"GitFileDiff"}
3307
3308func (ec *executionContext) _GitFileDiff(ctx context.Context, sel ast.SelectionSet, obj *repository.FileDiff) graphql.Marshaler {
3309	fields := graphql.CollectFields(ec.OperationContext, sel, gitFileDiffImplementors)
3310
3311	out := graphql.NewFieldSet(fields)
3312	deferred := make(map[string]*graphql.FieldSet)
3313	for i, field := range fields {
3314		switch field.Name {
3315		case "__typename":
3316			out.Values[i] = graphql.MarshalString("GitFileDiff")
3317		case "path":
3318			out.Values[i] = ec._GitFileDiff_path(ctx, field, obj)
3319			if out.Values[i] == graphql.Null {
3320				out.Invalids++
3321			}
3322		case "oldPath":
3323			out.Values[i] = ec._GitFileDiff_oldPath(ctx, field, obj)
3324		case "isBinary":
3325			out.Values[i] = ec._GitFileDiff_isBinary(ctx, field, obj)
3326			if out.Values[i] == graphql.Null {
3327				out.Invalids++
3328			}
3329		case "isNew":
3330			out.Values[i] = ec._GitFileDiff_isNew(ctx, field, obj)
3331			if out.Values[i] == graphql.Null {
3332				out.Invalids++
3333			}
3334		case "isDelete":
3335			out.Values[i] = ec._GitFileDiff_isDelete(ctx, field, obj)
3336			if out.Values[i] == graphql.Null {
3337				out.Invalids++
3338			}
3339		case "hunks":
3340			out.Values[i] = ec._GitFileDiff_hunks(ctx, field, obj)
3341			if out.Values[i] == graphql.Null {
3342				out.Invalids++
3343			}
3344		default:
3345			panic("unknown field " + strconv.Quote(field.Name))
3346		}
3347	}
3348	out.Dispatch(ctx)
3349	if out.Invalids > 0 {
3350		return graphql.Null
3351	}
3352
3353	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3354
3355	for label, dfs := range deferred {
3356		ec.processDeferredGroup(graphql.DeferredGroup{
3357			Label:    label,
3358			Path:     graphql.GetPath(ctx),
3359			FieldSet: dfs,
3360			Context:  ctx,
3361		})
3362	}
3363
3364	return out
3365}
3366
3367var gitLastCommitImplementors = []string{"GitLastCommit"}
3368
3369func (ec *executionContext) _GitLastCommit(ctx context.Context, sel ast.SelectionSet, obj *models.GitLastCommit) graphql.Marshaler {
3370	fields := graphql.CollectFields(ec.OperationContext, sel, gitLastCommitImplementors)
3371
3372	out := graphql.NewFieldSet(fields)
3373	deferred := make(map[string]*graphql.FieldSet)
3374	for i, field := range fields {
3375		switch field.Name {
3376		case "__typename":
3377			out.Values[i] = graphql.MarshalString("GitLastCommit")
3378		case "name":
3379			out.Values[i] = ec._GitLastCommit_name(ctx, field, obj)
3380			if out.Values[i] == graphql.Null {
3381				out.Invalids++
3382			}
3383		case "commit":
3384			out.Values[i] = ec._GitLastCommit_commit(ctx, field, obj)
3385			if out.Values[i] == graphql.Null {
3386				out.Invalids++
3387			}
3388		default:
3389			panic("unknown field " + strconv.Quote(field.Name))
3390		}
3391	}
3392	out.Dispatch(ctx)
3393	if out.Invalids > 0 {
3394		return graphql.Null
3395	}
3396
3397	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3398
3399	for label, dfs := range deferred {
3400		ec.processDeferredGroup(graphql.DeferredGroup{
3401			Label:    label,
3402			Path:     graphql.GetPath(ctx),
3403			FieldSet: dfs,
3404			Context:  ctx,
3405		})
3406	}
3407
3408	return out
3409}
3410
3411var gitRefImplementors = []string{"GitRef"}
3412
3413func (ec *executionContext) _GitRef(ctx context.Context, sel ast.SelectionSet, obj *models.GitRef) graphql.Marshaler {
3414	fields := graphql.CollectFields(ec.OperationContext, sel, gitRefImplementors)
3415
3416	out := graphql.NewFieldSet(fields)
3417	deferred := make(map[string]*graphql.FieldSet)
3418	for i, field := range fields {
3419		switch field.Name {
3420		case "__typename":
3421			out.Values[i] = graphql.MarshalString("GitRef")
3422		case "name":
3423			out.Values[i] = ec._GitRef_name(ctx, field, obj)
3424			if out.Values[i] == graphql.Null {
3425				atomic.AddUint32(&out.Invalids, 1)
3426			}
3427		case "shortName":
3428			out.Values[i] = ec._GitRef_shortName(ctx, field, obj)
3429			if out.Values[i] == graphql.Null {
3430				atomic.AddUint32(&out.Invalids, 1)
3431			}
3432		case "type":
3433			out.Values[i] = ec._GitRef_type(ctx, field, obj)
3434			if out.Values[i] == graphql.Null {
3435				atomic.AddUint32(&out.Invalids, 1)
3436			}
3437		case "hash":
3438			out.Values[i] = ec._GitRef_hash(ctx, field, obj)
3439			if out.Values[i] == graphql.Null {
3440				atomic.AddUint32(&out.Invalids, 1)
3441			}
3442		case "commit":
3443			field := field
3444
3445			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
3446				defer func() {
3447					if r := recover(); r != nil {
3448						ec.Error(ctx, ec.Recover(ctx, r))
3449					}
3450				}()
3451				res = ec._GitRef_commit(ctx, field, obj)
3452				if res == graphql.Null {
3453					atomic.AddUint32(&fs.Invalids, 1)
3454				}
3455				return res
3456			}
3457
3458			if field.Deferrable != nil {
3459				dfs, ok := deferred[field.Deferrable.Label]
3460				di := 0
3461				if ok {
3462					dfs.AddField(field)
3463					di = len(dfs.Values) - 1
3464				} else {
3465					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
3466					deferred[field.Deferrable.Label] = dfs
3467				}
3468				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
3469					return innerFunc(ctx, dfs)
3470				})
3471
3472				// don't run the out.Concurrently() call below
3473				out.Values[i] = graphql.Null
3474				continue
3475			}
3476
3477			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3478		default:
3479			panic("unknown field " + strconv.Quote(field.Name))
3480		}
3481	}
3482	out.Dispatch(ctx)
3483	if out.Invalids > 0 {
3484		return graphql.Null
3485	}
3486
3487	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3488
3489	for label, dfs := range deferred {
3490		ec.processDeferredGroup(graphql.DeferredGroup{
3491			Label:    label,
3492			Path:     graphql.GetPath(ctx),
3493			FieldSet: dfs,
3494			Context:  ctx,
3495		})
3496	}
3497
3498	return out
3499}
3500
3501var gitRefConnectionImplementors = []string{"GitRefConnection"}
3502
3503func (ec *executionContext) _GitRefConnection(ctx context.Context, sel ast.SelectionSet, obj *models.GitRefConnection) graphql.Marshaler {
3504	fields := graphql.CollectFields(ec.OperationContext, sel, gitRefConnectionImplementors)
3505
3506	out := graphql.NewFieldSet(fields)
3507	deferred := make(map[string]*graphql.FieldSet)
3508	for i, field := range fields {
3509		switch field.Name {
3510		case "__typename":
3511			out.Values[i] = graphql.MarshalString("GitRefConnection")
3512		case "nodes":
3513			out.Values[i] = ec._GitRefConnection_nodes(ctx, field, obj)
3514			if out.Values[i] == graphql.Null {
3515				out.Invalids++
3516			}
3517		case "pageInfo":
3518			out.Values[i] = ec._GitRefConnection_pageInfo(ctx, field, obj)
3519			if out.Values[i] == graphql.Null {
3520				out.Invalids++
3521			}
3522		case "totalCount":
3523			out.Values[i] = ec._GitRefConnection_totalCount(ctx, field, obj)
3524			if out.Values[i] == graphql.Null {
3525				out.Invalids++
3526			}
3527		default:
3528			panic("unknown field " + strconv.Quote(field.Name))
3529		}
3530	}
3531	out.Dispatch(ctx)
3532	if out.Invalids > 0 {
3533		return graphql.Null
3534	}
3535
3536	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3537
3538	for label, dfs := range deferred {
3539		ec.processDeferredGroup(graphql.DeferredGroup{
3540			Label:    label,
3541			Path:     graphql.GetPath(ctx),
3542			FieldSet: dfs,
3543			Context:  ctx,
3544		})
3545	}
3546
3547	return out
3548}
3549
3550var gitTreeEntryImplementors = []string{"GitTreeEntry"}
3551
3552func (ec *executionContext) _GitTreeEntry(ctx context.Context, sel ast.SelectionSet, obj *models.GitTreeEntry) graphql.Marshaler {
3553	fields := graphql.CollectFields(ec.OperationContext, sel, gitTreeEntryImplementors)
3554
3555	out := graphql.NewFieldSet(fields)
3556	deferred := make(map[string]*graphql.FieldSet)
3557	for i, field := range fields {
3558		switch field.Name {
3559		case "__typename":
3560			out.Values[i] = graphql.MarshalString("GitTreeEntry")
3561		case "name":
3562			out.Values[i] = ec._GitTreeEntry_name(ctx, field, obj)
3563			if out.Values[i] == graphql.Null {
3564				atomic.AddUint32(&out.Invalids, 1)
3565			}
3566		case "type":
3567			out.Values[i] = ec._GitTreeEntry_type(ctx, field, obj)
3568			if out.Values[i] == graphql.Null {
3569				atomic.AddUint32(&out.Invalids, 1)
3570			}
3571		case "hash":
3572			out.Values[i] = ec._GitTreeEntry_hash(ctx, field, obj)
3573			if out.Values[i] == graphql.Null {
3574				atomic.AddUint32(&out.Invalids, 1)
3575			}
3576		case "lastCommit":
3577			field := field
3578
3579			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
3580				defer func() {
3581					if r := recover(); r != nil {
3582						ec.Error(ctx, ec.Recover(ctx, r))
3583					}
3584				}()
3585				res = ec._GitTreeEntry_lastCommit(ctx, field, obj)
3586				return res
3587			}
3588
3589			if field.Deferrable != nil {
3590				dfs, ok := deferred[field.Deferrable.Label]
3591				di := 0
3592				if ok {
3593					dfs.AddField(field)
3594					di = len(dfs.Values) - 1
3595				} else {
3596					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
3597					deferred[field.Deferrable.Label] = dfs
3598				}
3599				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
3600					return innerFunc(ctx, dfs)
3601				})
3602
3603				// don't run the out.Concurrently() call below
3604				out.Values[i] = graphql.Null
3605				continue
3606			}
3607
3608			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
3609		default:
3610			panic("unknown field " + strconv.Quote(field.Name))
3611		}
3612	}
3613	out.Dispatch(ctx)
3614	if out.Invalids > 0 {
3615		return graphql.Null
3616	}
3617
3618	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
3619
3620	for label, dfs := range deferred {
3621		ec.processDeferredGroup(graphql.DeferredGroup{
3622			Label:    label,
3623			Path:     graphql.GetPath(ctx),
3624			FieldSet: dfs,
3625			Context:  ctx,
3626		})
3627	}
3628
3629	return out
3630}
3631
3632// endregion **************************** object.gotpl ****************************
3633
3634// region    ***************************** type.gotpl *****************************
3635
3636func (ec *executionContext) unmarshalNGitChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangeStatus(ctx context.Context, v any) (repository.ChangeStatus, error) {
3637	var res repository.ChangeStatus
3638	err := res.UnmarshalGQL(v)
3639	return res, graphql.ErrorOnPath(ctx, err)
3640}
3641
3642func (ec *executionContext) marshalNGitChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangeStatus(ctx context.Context, sel ast.SelectionSet, v repository.ChangeStatus) graphql.Marshaler {
3643	return v
3644}
3645
3646func (ec *executionContext) marshalNGitChangedFile2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangedFileᚄ(ctx context.Context, sel ast.SelectionSet, v []*repository.ChangedFile) graphql.Marshaler {
3647	ret := make(graphql.Array, len(v))
3648	var wg sync.WaitGroup
3649	isLen1 := len(v) == 1
3650	if !isLen1 {
3651		wg.Add(len(v))
3652	}
3653	for i := range v {
3654		i := i
3655		fc := &graphql.FieldContext{
3656			Index:  &i,
3657			Result: &v[i],
3658		}
3659		ctx := graphql.WithFieldContext(ctx, fc)
3660		f := func(i int) {
3661			defer func() {
3662				if r := recover(); r != nil {
3663					ec.Error(ctx, ec.Recover(ctx, r))
3664					ret = nil
3665				}
3666			}()
3667			if !isLen1 {
3668				defer wg.Done()
3669			}
3670			ret[i] = ec.marshalNGitChangedFile2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangedFile(ctx, sel, v[i])
3671		}
3672		if isLen1 {
3673			f(i)
3674		} else {
3675			go f(i)
3676		}
3677
3678	}
3679	wg.Wait()
3680
3681	for _, e := range ret {
3682		if e == graphql.Null {
3683			return graphql.Null
3684		}
3685	}
3686
3687	return ret
3688}
3689
3690func (ec *executionContext) marshalNGitChangedFile2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐChangedFile(ctx context.Context, sel ast.SelectionSet, v *repository.ChangedFile) graphql.Marshaler {
3691	if v == nil {
3692		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3693			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3694		}
3695		return graphql.Null
3696	}
3697	return ec._GitChangedFile(ctx, sel, v)
3698}
3699
3700func (ec *executionContext) marshalNGitChangedFileConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitChangedFileConnection(ctx context.Context, sel ast.SelectionSet, v models.GitChangedFileConnection) graphql.Marshaler {
3701	return ec._GitChangedFileConnection(ctx, sel, &v)
3702}
3703
3704func (ec *executionContext) marshalNGitChangedFileConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitChangedFileConnection(ctx context.Context, sel ast.SelectionSet, v *models.GitChangedFileConnection) graphql.Marshaler {
3705	if v == nil {
3706		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3707			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3708		}
3709		return graphql.Null
3710	}
3711	return ec._GitChangedFileConnection(ctx, sel, v)
3712}
3713
3714func (ec *executionContext) marshalNGitCommit2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx context.Context, sel ast.SelectionSet, v models.GitCommitMeta) graphql.Marshaler {
3715	return ec._GitCommit(ctx, sel, &v)
3716}
3717
3718func (ec *executionContext) marshalNGitCommit2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMetaᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.GitCommitMeta) graphql.Marshaler {
3719	ret := make(graphql.Array, len(v))
3720	var wg sync.WaitGroup
3721	isLen1 := len(v) == 1
3722	if !isLen1 {
3723		wg.Add(len(v))
3724	}
3725	for i := range v {
3726		i := i
3727		fc := &graphql.FieldContext{
3728			Index:  &i,
3729			Result: &v[i],
3730		}
3731		ctx := graphql.WithFieldContext(ctx, fc)
3732		f := func(i int) {
3733			defer func() {
3734				if r := recover(); r != nil {
3735					ec.Error(ctx, ec.Recover(ctx, r))
3736					ret = nil
3737				}
3738			}()
3739			if !isLen1 {
3740				defer wg.Done()
3741			}
3742			ret[i] = ec.marshalNGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx, sel, v[i])
3743		}
3744		if isLen1 {
3745			f(i)
3746		} else {
3747			go f(i)
3748		}
3749
3750	}
3751	wg.Wait()
3752
3753	for _, e := range ret {
3754		if e == graphql.Null {
3755			return graphql.Null
3756		}
3757	}
3758
3759	return ret
3760}
3761
3762func (ec *executionContext) marshalNGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx context.Context, sel ast.SelectionSet, v *models.GitCommitMeta) graphql.Marshaler {
3763	if v == nil {
3764		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3765			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3766		}
3767		return graphql.Null
3768	}
3769	return ec._GitCommit(ctx, sel, v)
3770}
3771
3772func (ec *executionContext) marshalNGitCommitConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitConnection(ctx context.Context, sel ast.SelectionSet, v models.GitCommitConnection) graphql.Marshaler {
3773	return ec._GitCommitConnection(ctx, sel, &v)
3774}
3775
3776func (ec *executionContext) marshalNGitCommitConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitConnection(ctx context.Context, sel ast.SelectionSet, v *models.GitCommitConnection) graphql.Marshaler {
3777	if v == nil {
3778		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3779			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3780		}
3781		return graphql.Null
3782	}
3783	return ec._GitCommitConnection(ctx, sel, v)
3784}
3785
3786func (ec *executionContext) marshalNGitDiffHunk2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffHunk(ctx context.Context, sel ast.SelectionSet, v repository.DiffHunk) graphql.Marshaler {
3787	return ec._GitDiffHunk(ctx, sel, &v)
3788}
3789
3790func (ec *executionContext) marshalNGitDiffHunk2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffHunkᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.DiffHunk) graphql.Marshaler {
3791	ret := make(graphql.Array, len(v))
3792	var wg sync.WaitGroup
3793	isLen1 := len(v) == 1
3794	if !isLen1 {
3795		wg.Add(len(v))
3796	}
3797	for i := range v {
3798		i := i
3799		fc := &graphql.FieldContext{
3800			Index:  &i,
3801			Result: &v[i],
3802		}
3803		ctx := graphql.WithFieldContext(ctx, fc)
3804		f := func(i int) {
3805			defer func() {
3806				if r := recover(); r != nil {
3807					ec.Error(ctx, ec.Recover(ctx, r))
3808					ret = nil
3809				}
3810			}()
3811			if !isLen1 {
3812				defer wg.Done()
3813			}
3814			ret[i] = ec.marshalNGitDiffHunk2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffHunk(ctx, sel, v[i])
3815		}
3816		if isLen1 {
3817			f(i)
3818		} else {
3819			go f(i)
3820		}
3821
3822	}
3823	wg.Wait()
3824
3825	for _, e := range ret {
3826		if e == graphql.Null {
3827			return graphql.Null
3828		}
3829	}
3830
3831	return ret
3832}
3833
3834func (ec *executionContext) marshalNGitDiffLine2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLine(ctx context.Context, sel ast.SelectionSet, v repository.DiffLine) graphql.Marshaler {
3835	return ec._GitDiffLine(ctx, sel, &v)
3836}
3837
3838func (ec *executionContext) marshalNGitDiffLine2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLineᚄ(ctx context.Context, sel ast.SelectionSet, v []repository.DiffLine) graphql.Marshaler {
3839	ret := make(graphql.Array, len(v))
3840	var wg sync.WaitGroup
3841	isLen1 := len(v) == 1
3842	if !isLen1 {
3843		wg.Add(len(v))
3844	}
3845	for i := range v {
3846		i := i
3847		fc := &graphql.FieldContext{
3848			Index:  &i,
3849			Result: &v[i],
3850		}
3851		ctx := graphql.WithFieldContext(ctx, fc)
3852		f := func(i int) {
3853			defer func() {
3854				if r := recover(); r != nil {
3855					ec.Error(ctx, ec.Recover(ctx, r))
3856					ret = nil
3857				}
3858			}()
3859			if !isLen1 {
3860				defer wg.Done()
3861			}
3862			ret[i] = ec.marshalNGitDiffLine2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLine(ctx, sel, v[i])
3863		}
3864		if isLen1 {
3865			f(i)
3866		} else {
3867			go f(i)
3868		}
3869
3870	}
3871	wg.Wait()
3872
3873	for _, e := range ret {
3874		if e == graphql.Null {
3875			return graphql.Null
3876		}
3877	}
3878
3879	return ret
3880}
3881
3882func (ec *executionContext) unmarshalNGitDiffLineType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLineType(ctx context.Context, v any) (repository.DiffLineType, error) {
3883	var res repository.DiffLineType
3884	err := res.UnmarshalGQL(v)
3885	return res, graphql.ErrorOnPath(ctx, err)
3886}
3887
3888func (ec *executionContext) marshalNGitDiffLineType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐDiffLineType(ctx context.Context, sel ast.SelectionSet, v repository.DiffLineType) graphql.Marshaler {
3889	return v
3890}
3891
3892func (ec *executionContext) marshalNGitLastCommit2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitLastCommitᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.GitLastCommit) graphql.Marshaler {
3893	ret := make(graphql.Array, len(v))
3894	var wg sync.WaitGroup
3895	isLen1 := len(v) == 1
3896	if !isLen1 {
3897		wg.Add(len(v))
3898	}
3899	for i := range v {
3900		i := i
3901		fc := &graphql.FieldContext{
3902			Index:  &i,
3903			Result: &v[i],
3904		}
3905		ctx := graphql.WithFieldContext(ctx, fc)
3906		f := func(i int) {
3907			defer func() {
3908				if r := recover(); r != nil {
3909					ec.Error(ctx, ec.Recover(ctx, r))
3910					ret = nil
3911				}
3912			}()
3913			if !isLen1 {
3914				defer wg.Done()
3915			}
3916			ret[i] = ec.marshalNGitLastCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitLastCommit(ctx, sel, v[i])
3917		}
3918		if isLen1 {
3919			f(i)
3920		} else {
3921			go f(i)
3922		}
3923
3924	}
3925	wg.Wait()
3926
3927	for _, e := range ret {
3928		if e == graphql.Null {
3929			return graphql.Null
3930		}
3931	}
3932
3933	return ret
3934}
3935
3936func (ec *executionContext) marshalNGitLastCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitLastCommit(ctx context.Context, sel ast.SelectionSet, v *models.GitLastCommit) graphql.Marshaler {
3937	if v == nil {
3938		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
3939			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
3940		}
3941		return graphql.Null
3942	}
3943	return ec._GitLastCommit(ctx, sel, v)
3944}
3945
3946func (ec *executionContext) unmarshalNGitObjectType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐObjectType(ctx context.Context, v any) (repository.ObjectType, error) {
3947	var res repository.ObjectType
3948	err := res.UnmarshalGQL(v)
3949	return res, graphql.ErrorOnPath(ctx, err)
3950}
3951
3952func (ec *executionContext) marshalNGitObjectType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐObjectType(ctx context.Context, sel ast.SelectionSet, v repository.ObjectType) graphql.Marshaler {
3953	return v
3954}
3955
3956func (ec *executionContext) marshalNGitRef2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.GitRef) graphql.Marshaler {
3957	ret := make(graphql.Array, len(v))
3958	var wg sync.WaitGroup
3959	isLen1 := len(v) == 1
3960	if !isLen1 {
3961		wg.Add(len(v))
3962	}
3963	for i := range v {
3964		i := i
3965		fc := &graphql.FieldContext{
3966			Index:  &i,
3967			Result: &v[i],
3968		}
3969		ctx := graphql.WithFieldContext(ctx, fc)
3970		f := func(i int) {
3971			defer func() {
3972				if r := recover(); r != nil {
3973					ec.Error(ctx, ec.Recover(ctx, r))
3974					ret = nil
3975				}
3976			}()
3977			if !isLen1 {
3978				defer wg.Done()
3979			}
3980			ret[i] = ec.marshalNGitRef2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRef(ctx, sel, v[i])
3981		}
3982		if isLen1 {
3983			f(i)
3984		} else {
3985			go f(i)
3986		}
3987
3988	}
3989	wg.Wait()
3990
3991	for _, e := range ret {
3992		if e == graphql.Null {
3993			return graphql.Null
3994		}
3995	}
3996
3997	return ret
3998}
3999
4000func (ec *executionContext) marshalNGitRef2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRef(ctx context.Context, sel ast.SelectionSet, v *models.GitRef) graphql.Marshaler {
4001	if v == nil {
4002		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
4003			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
4004		}
4005		return graphql.Null
4006	}
4007	return ec._GitRef(ctx, sel, v)
4008}
4009
4010func (ec *executionContext) marshalNGitRefConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefConnection(ctx context.Context, sel ast.SelectionSet, v models.GitRefConnection) graphql.Marshaler {
4011	return ec._GitRefConnection(ctx, sel, &v)
4012}
4013
4014func (ec *executionContext) marshalNGitRefConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefConnection(ctx context.Context, sel ast.SelectionSet, v *models.GitRefConnection) graphql.Marshaler {
4015	if v == nil {
4016		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
4017			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
4018		}
4019		return graphql.Null
4020	}
4021	return ec._GitRefConnection(ctx, sel, v)
4022}
4023
4024func (ec *executionContext) unmarshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType(ctx context.Context, v any) (repository.GitRefType, error) {
4025	tmp, err := graphql.UnmarshalString(v)
4026	res := unmarshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType[tmp]
4027	return res, graphql.ErrorOnPath(ctx, err)
4028}
4029
4030func (ec *executionContext) marshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType(ctx context.Context, sel ast.SelectionSet, v repository.GitRefType) graphql.Marshaler {
4031	_ = sel
4032	res := graphql.MarshalString(marshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType[v])
4033	if res == graphql.Null {
4034		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
4035			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
4036		}
4037	}
4038	return res
4039}
4040
4041var (
4042	unmarshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType = map[string]repository.GitRefType{
4043		"BRANCH": repository.GitRefTypeBranch,
4044		"TAG":    repository.GitRefTypeTag,
4045		"COMMIT": repository.GitRefTypeCommit,
4046	}
4047	marshalNGitRefType2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType = map[repository.GitRefType]string{
4048		repository.GitRefTypeBranch: "BRANCH",
4049		repository.GitRefTypeTag:    "TAG",
4050		repository.GitRefTypeCommit: "COMMIT",
4051	}
4052)
4053
4054func (ec *executionContext) marshalNGitTreeEntry2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitTreeEntryᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.GitTreeEntry) graphql.Marshaler {
4055	ret := make(graphql.Array, len(v))
4056	var wg sync.WaitGroup
4057	isLen1 := len(v) == 1
4058	if !isLen1 {
4059		wg.Add(len(v))
4060	}
4061	for i := range v {
4062		i := i
4063		fc := &graphql.FieldContext{
4064			Index:  &i,
4065			Result: &v[i],
4066		}
4067		ctx := graphql.WithFieldContext(ctx, fc)
4068		f := func(i int) {
4069			defer func() {
4070				if r := recover(); r != nil {
4071					ec.Error(ctx, ec.Recover(ctx, r))
4072					ret = nil
4073				}
4074			}()
4075			if !isLen1 {
4076				defer wg.Done()
4077			}
4078			ret[i] = ec.marshalNGitTreeEntry2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitTreeEntry(ctx, sel, v[i])
4079		}
4080		if isLen1 {
4081			f(i)
4082		} else {
4083			go f(i)
4084		}
4085
4086	}
4087	wg.Wait()
4088
4089	for _, e := range ret {
4090		if e == graphql.Null {
4091			return graphql.Null
4092		}
4093	}
4094
4095	return ret
4096}
4097
4098func (ec *executionContext) marshalNGitTreeEntry2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitTreeEntry(ctx context.Context, sel ast.SelectionSet, v *models.GitTreeEntry) graphql.Marshaler {
4099	if v == nil {
4100		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
4101			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
4102		}
4103		return graphql.Null
4104	}
4105	return ec._GitTreeEntry(ctx, sel, v)
4106}
4107
4108func (ec *executionContext) marshalOGitBlob2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitBlob(ctx context.Context, sel ast.SelectionSet, v *models.GitBlob) graphql.Marshaler {
4109	if v == nil {
4110		return graphql.Null
4111	}
4112	return ec._GitBlob(ctx, sel, v)
4113}
4114
4115func (ec *executionContext) marshalOGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx context.Context, sel ast.SelectionSet, v *models.GitCommitMeta) graphql.Marshaler {
4116	if v == nil {
4117		return graphql.Null
4118	}
4119	return ec._GitCommit(ctx, sel, v)
4120}
4121
4122func (ec *executionContext) marshalOGitFileDiff2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐFileDiff(ctx context.Context, sel ast.SelectionSet, v *repository.FileDiff) graphql.Marshaler {
4123	if v == nil {
4124		return graphql.Null
4125	}
4126	return ec._GitFileDiff(ctx, sel, v)
4127}
4128
4129func (ec *executionContext) marshalOGitRef2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRef(ctx context.Context, sel ast.SelectionSet, v *models.GitRef) graphql.Marshaler {
4130	if v == nil {
4131		return graphql.Null
4132	}
4133	return ec._GitRef(ctx, sel, v)
4134}
4135
4136func (ec *executionContext) unmarshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType(ctx context.Context, v any) (*repository.GitRefType, error) {
4137	if v == nil {
4138		return nil, nil
4139	}
4140	tmp, err := graphql.UnmarshalString(v)
4141	res := unmarshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType[tmp]
4142	return &res, graphql.ErrorOnPath(ctx, err)
4143}
4144
4145func (ec *executionContext) marshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType(ctx context.Context, sel ast.SelectionSet, v *repository.GitRefType) graphql.Marshaler {
4146	if v == nil {
4147		return graphql.Null
4148	}
4149	_ = sel
4150	_ = ctx
4151	res := graphql.MarshalString(marshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType[*v])
4152	return res
4153}
4154
4155var (
4156	unmarshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType = map[string]repository.GitRefType{
4157		"BRANCH": repository.GitRefTypeBranch,
4158		"TAG":    repository.GitRefTypeTag,
4159		"COMMIT": repository.GitRefTypeCommit,
4160	}
4161	marshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐGitRefType = map[repository.GitRefType]string{
4162		repository.GitRefTypeBranch: "BRANCH",
4163		repository.GitRefTypeTag:    "TAG",
4164		repository.GitRefTypeCommit: "COMMIT",
4165	}
4166)
4167
4168// endregion ***************************** type.gotpl *****************************