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 RepositoryResolver interface {
  23	Name(ctx context.Context, obj *models.Repository) (*string, error)
  24	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  25	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  26	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  27	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  28	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  29	Refs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, typeArg *models.GitRefType) (*models.GitRefConnection, error)
  30	Tree(ctx context.Context, obj *models.Repository, ref string, path *string) ([]*repository.TreeEntry, error)
  31	Blob(ctx context.Context, obj *models.Repository, ref string, path string) (*models.GitBlob, error)
  32	Commits(ctx context.Context, obj *models.Repository, after *string, first *int, ref string, path *string, since *time.Time, until *time.Time) (*models.GitCommitConnection, error)
  33	Commit(ctx context.Context, obj *models.Repository, hash string) (*models.GitCommitMeta, error)
  34	LastCommits(ctx context.Context, obj *models.Repository, ref string, path *string, names []string) ([]*models.GitLastCommit, error)
  35	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  36}
  37
  38// endregion ************************** generated!.gotpl **************************
  39
  40// region    ***************************** args.gotpl *****************************
  41
  42func (ec *executionContext) field_Repository_allBugs_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_Repository_allBugs_argsAfter(ctx, rawArgs)
  46	if err != nil {
  47		return nil, err
  48	}
  49	args["after"] = arg0
  50	arg1, err := ec.field_Repository_allBugs_argsBefore(ctx, rawArgs)
  51	if err != nil {
  52		return nil, err
  53	}
  54	args["before"] = arg1
  55	arg2, err := ec.field_Repository_allBugs_argsFirst(ctx, rawArgs)
  56	if err != nil {
  57		return nil, err
  58	}
  59	args["first"] = arg2
  60	arg3, err := ec.field_Repository_allBugs_argsLast(ctx, rawArgs)
  61	if err != nil {
  62		return nil, err
  63	}
  64	args["last"] = arg3
  65	arg4, err := ec.field_Repository_allBugs_argsQuery(ctx, rawArgs)
  66	if err != nil {
  67		return nil, err
  68	}
  69	args["query"] = arg4
  70	return args, nil
  71}
  72func (ec *executionContext) field_Repository_allBugs_argsAfter(
  73	ctx context.Context,
  74	rawArgs map[string]any,
  75) (*string, error) {
  76	if _, ok := rawArgs["after"]; !ok {
  77		var zeroVal *string
  78		return zeroVal, nil
  79	}
  80
  81	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
  82	if tmp, ok := rawArgs["after"]; ok {
  83		return ec.unmarshalOString2ᚖstring(ctx, tmp)
  84	}
  85
  86	var zeroVal *string
  87	return zeroVal, nil
  88}
  89
  90func (ec *executionContext) field_Repository_allBugs_argsBefore(
  91	ctx context.Context,
  92	rawArgs map[string]any,
  93) (*string, error) {
  94	if _, ok := rawArgs["before"]; !ok {
  95		var zeroVal *string
  96		return zeroVal, nil
  97	}
  98
  99	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 100	if tmp, ok := rawArgs["before"]; ok {
 101		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 102	}
 103
 104	var zeroVal *string
 105	return zeroVal, nil
 106}
 107
 108func (ec *executionContext) field_Repository_allBugs_argsFirst(
 109	ctx context.Context,
 110	rawArgs map[string]any,
 111) (*int, error) {
 112	if _, ok := rawArgs["first"]; !ok {
 113		var zeroVal *int
 114		return zeroVal, nil
 115	}
 116
 117	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 118	if tmp, ok := rawArgs["first"]; ok {
 119		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 120	}
 121
 122	var zeroVal *int
 123	return zeroVal, nil
 124}
 125
 126func (ec *executionContext) field_Repository_allBugs_argsLast(
 127	ctx context.Context,
 128	rawArgs map[string]any,
 129) (*int, error) {
 130	if _, ok := rawArgs["last"]; !ok {
 131		var zeroVal *int
 132		return zeroVal, nil
 133	}
 134
 135	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 136	if tmp, ok := rawArgs["last"]; ok {
 137		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 138	}
 139
 140	var zeroVal *int
 141	return zeroVal, nil
 142}
 143
 144func (ec *executionContext) field_Repository_allBugs_argsQuery(
 145	ctx context.Context,
 146	rawArgs map[string]any,
 147) (*string, error) {
 148	if _, ok := rawArgs["query"]; !ok {
 149		var zeroVal *string
 150		return zeroVal, nil
 151	}
 152
 153	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
 154	if tmp, ok := rawArgs["query"]; ok {
 155		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 156	}
 157
 158	var zeroVal *string
 159	return zeroVal, nil
 160}
 161
 162func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 163	var err error
 164	args := map[string]any{}
 165	arg0, err := ec.field_Repository_allIdentities_argsAfter(ctx, rawArgs)
 166	if err != nil {
 167		return nil, err
 168	}
 169	args["after"] = arg0
 170	arg1, err := ec.field_Repository_allIdentities_argsBefore(ctx, rawArgs)
 171	if err != nil {
 172		return nil, err
 173	}
 174	args["before"] = arg1
 175	arg2, err := ec.field_Repository_allIdentities_argsFirst(ctx, rawArgs)
 176	if err != nil {
 177		return nil, err
 178	}
 179	args["first"] = arg2
 180	arg3, err := ec.field_Repository_allIdentities_argsLast(ctx, rawArgs)
 181	if err != nil {
 182		return nil, err
 183	}
 184	args["last"] = arg3
 185	return args, nil
 186}
 187func (ec *executionContext) field_Repository_allIdentities_argsAfter(
 188	ctx context.Context,
 189	rawArgs map[string]any,
 190) (*string, error) {
 191	if _, ok := rawArgs["after"]; !ok {
 192		var zeroVal *string
 193		return zeroVal, nil
 194	}
 195
 196	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 197	if tmp, ok := rawArgs["after"]; ok {
 198		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 199	}
 200
 201	var zeroVal *string
 202	return zeroVal, nil
 203}
 204
 205func (ec *executionContext) field_Repository_allIdentities_argsBefore(
 206	ctx context.Context,
 207	rawArgs map[string]any,
 208) (*string, error) {
 209	if _, ok := rawArgs["before"]; !ok {
 210		var zeroVal *string
 211		return zeroVal, nil
 212	}
 213
 214	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 215	if tmp, ok := rawArgs["before"]; ok {
 216		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 217	}
 218
 219	var zeroVal *string
 220	return zeroVal, nil
 221}
 222
 223func (ec *executionContext) field_Repository_allIdentities_argsFirst(
 224	ctx context.Context,
 225	rawArgs map[string]any,
 226) (*int, error) {
 227	if _, ok := rawArgs["first"]; !ok {
 228		var zeroVal *int
 229		return zeroVal, nil
 230	}
 231
 232	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 233	if tmp, ok := rawArgs["first"]; ok {
 234		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 235	}
 236
 237	var zeroVal *int
 238	return zeroVal, nil
 239}
 240
 241func (ec *executionContext) field_Repository_allIdentities_argsLast(
 242	ctx context.Context,
 243	rawArgs map[string]any,
 244) (*int, error) {
 245	if _, ok := rawArgs["last"]; !ok {
 246		var zeroVal *int
 247		return zeroVal, nil
 248	}
 249
 250	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 251	if tmp, ok := rawArgs["last"]; ok {
 252		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 253	}
 254
 255	var zeroVal *int
 256	return zeroVal, nil
 257}
 258
 259func (ec *executionContext) field_Repository_blob_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 260	var err error
 261	args := map[string]any{}
 262	arg0, err := ec.field_Repository_blob_argsRef(ctx, rawArgs)
 263	if err != nil {
 264		return nil, err
 265	}
 266	args["ref"] = arg0
 267	arg1, err := ec.field_Repository_blob_argsPath(ctx, rawArgs)
 268	if err != nil {
 269		return nil, err
 270	}
 271	args["path"] = arg1
 272	return args, nil
 273}
 274func (ec *executionContext) field_Repository_blob_argsRef(
 275	ctx context.Context,
 276	rawArgs map[string]any,
 277) (string, error) {
 278	if _, ok := rawArgs["ref"]; !ok {
 279		var zeroVal string
 280		return zeroVal, nil
 281	}
 282
 283	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
 284	if tmp, ok := rawArgs["ref"]; ok {
 285		return ec.unmarshalNString2string(ctx, tmp)
 286	}
 287
 288	var zeroVal string
 289	return zeroVal, nil
 290}
 291
 292func (ec *executionContext) field_Repository_blob_argsPath(
 293	ctx context.Context,
 294	rawArgs map[string]any,
 295) (string, error) {
 296	if _, ok := rawArgs["path"]; !ok {
 297		var zeroVal string
 298		return zeroVal, nil
 299	}
 300
 301	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))
 302	if tmp, ok := rawArgs["path"]; ok {
 303		return ec.unmarshalNString2string(ctx, tmp)
 304	}
 305
 306	var zeroVal string
 307	return zeroVal, nil
 308}
 309
 310func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 311	var err error
 312	args := map[string]any{}
 313	arg0, err := ec.field_Repository_bug_argsPrefix(ctx, rawArgs)
 314	if err != nil {
 315		return nil, err
 316	}
 317	args["prefix"] = arg0
 318	return args, nil
 319}
 320func (ec *executionContext) field_Repository_bug_argsPrefix(
 321	ctx context.Context,
 322	rawArgs map[string]any,
 323) (string, error) {
 324	if _, ok := rawArgs["prefix"]; !ok {
 325		var zeroVal string
 326		return zeroVal, nil
 327	}
 328
 329	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
 330	if tmp, ok := rawArgs["prefix"]; ok {
 331		return ec.unmarshalNString2string(ctx, tmp)
 332	}
 333
 334	var zeroVal string
 335	return zeroVal, nil
 336}
 337
 338func (ec *executionContext) field_Repository_commit_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 339	var err error
 340	args := map[string]any{}
 341	arg0, err := ec.field_Repository_commit_argsHash(ctx, rawArgs)
 342	if err != nil {
 343		return nil, err
 344	}
 345	args["hash"] = arg0
 346	return args, nil
 347}
 348func (ec *executionContext) field_Repository_commit_argsHash(
 349	ctx context.Context,
 350	rawArgs map[string]any,
 351) (string, error) {
 352	if _, ok := rawArgs["hash"]; !ok {
 353		var zeroVal string
 354		return zeroVal, nil
 355	}
 356
 357	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("hash"))
 358	if tmp, ok := rawArgs["hash"]; ok {
 359		return ec.unmarshalNString2string(ctx, tmp)
 360	}
 361
 362	var zeroVal string
 363	return zeroVal, nil
 364}
 365
 366func (ec *executionContext) field_Repository_commits_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 367	var err error
 368	args := map[string]any{}
 369	arg0, err := ec.field_Repository_commits_argsAfter(ctx, rawArgs)
 370	if err != nil {
 371		return nil, err
 372	}
 373	args["after"] = arg0
 374	arg1, err := ec.field_Repository_commits_argsFirst(ctx, rawArgs)
 375	if err != nil {
 376		return nil, err
 377	}
 378	args["first"] = arg1
 379	arg2, err := ec.field_Repository_commits_argsRef(ctx, rawArgs)
 380	if err != nil {
 381		return nil, err
 382	}
 383	args["ref"] = arg2
 384	arg3, err := ec.field_Repository_commits_argsPath(ctx, rawArgs)
 385	if err != nil {
 386		return nil, err
 387	}
 388	args["path"] = arg3
 389	arg4, err := ec.field_Repository_commits_argsSince(ctx, rawArgs)
 390	if err != nil {
 391		return nil, err
 392	}
 393	args["since"] = arg4
 394	arg5, err := ec.field_Repository_commits_argsUntil(ctx, rawArgs)
 395	if err != nil {
 396		return nil, err
 397	}
 398	args["until"] = arg5
 399	return args, nil
 400}
 401func (ec *executionContext) field_Repository_commits_argsAfter(
 402	ctx context.Context,
 403	rawArgs map[string]any,
 404) (*string, error) {
 405	if _, ok := rawArgs["after"]; !ok {
 406		var zeroVal *string
 407		return zeroVal, nil
 408	}
 409
 410	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 411	if tmp, ok := rawArgs["after"]; ok {
 412		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 413	}
 414
 415	var zeroVal *string
 416	return zeroVal, nil
 417}
 418
 419func (ec *executionContext) field_Repository_commits_argsFirst(
 420	ctx context.Context,
 421	rawArgs map[string]any,
 422) (*int, error) {
 423	if _, ok := rawArgs["first"]; !ok {
 424		var zeroVal *int
 425		return zeroVal, nil
 426	}
 427
 428	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 429	if tmp, ok := rawArgs["first"]; ok {
 430		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 431	}
 432
 433	var zeroVal *int
 434	return zeroVal, nil
 435}
 436
 437func (ec *executionContext) field_Repository_commits_argsRef(
 438	ctx context.Context,
 439	rawArgs map[string]any,
 440) (string, error) {
 441	if _, ok := rawArgs["ref"]; !ok {
 442		var zeroVal string
 443		return zeroVal, nil
 444	}
 445
 446	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
 447	if tmp, ok := rawArgs["ref"]; ok {
 448		return ec.unmarshalNString2string(ctx, tmp)
 449	}
 450
 451	var zeroVal string
 452	return zeroVal, nil
 453}
 454
 455func (ec *executionContext) field_Repository_commits_argsPath(
 456	ctx context.Context,
 457	rawArgs map[string]any,
 458) (*string, error) {
 459	if _, ok := rawArgs["path"]; !ok {
 460		var zeroVal *string
 461		return zeroVal, nil
 462	}
 463
 464	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))
 465	if tmp, ok := rawArgs["path"]; ok {
 466		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 467	}
 468
 469	var zeroVal *string
 470	return zeroVal, nil
 471}
 472
 473func (ec *executionContext) field_Repository_commits_argsSince(
 474	ctx context.Context,
 475	rawArgs map[string]any,
 476) (*time.Time, error) {
 477	if _, ok := rawArgs["since"]; !ok {
 478		var zeroVal *time.Time
 479		return zeroVal, nil
 480	}
 481
 482	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("since"))
 483	if tmp, ok := rawArgs["since"]; ok {
 484		return ec.unmarshalOTime2ᚖtimeᚐTime(ctx, tmp)
 485	}
 486
 487	var zeroVal *time.Time
 488	return zeroVal, nil
 489}
 490
 491func (ec *executionContext) field_Repository_commits_argsUntil(
 492	ctx context.Context,
 493	rawArgs map[string]any,
 494) (*time.Time, error) {
 495	if _, ok := rawArgs["until"]; !ok {
 496		var zeroVal *time.Time
 497		return zeroVal, nil
 498	}
 499
 500	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("until"))
 501	if tmp, ok := rawArgs["until"]; ok {
 502		return ec.unmarshalOTime2ᚖtimeᚐTime(ctx, tmp)
 503	}
 504
 505	var zeroVal *time.Time
 506	return zeroVal, nil
 507}
 508
 509func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 510	var err error
 511	args := map[string]any{}
 512	arg0, err := ec.field_Repository_identity_argsPrefix(ctx, rawArgs)
 513	if err != nil {
 514		return nil, err
 515	}
 516	args["prefix"] = arg0
 517	return args, nil
 518}
 519func (ec *executionContext) field_Repository_identity_argsPrefix(
 520	ctx context.Context,
 521	rawArgs map[string]any,
 522) (string, error) {
 523	if _, ok := rawArgs["prefix"]; !ok {
 524		var zeroVal string
 525		return zeroVal, nil
 526	}
 527
 528	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
 529	if tmp, ok := rawArgs["prefix"]; ok {
 530		return ec.unmarshalNString2string(ctx, tmp)
 531	}
 532
 533	var zeroVal string
 534	return zeroVal, nil
 535}
 536
 537func (ec *executionContext) field_Repository_lastCommits_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 538	var err error
 539	args := map[string]any{}
 540	arg0, err := ec.field_Repository_lastCommits_argsRef(ctx, rawArgs)
 541	if err != nil {
 542		return nil, err
 543	}
 544	args["ref"] = arg0
 545	arg1, err := ec.field_Repository_lastCommits_argsPath(ctx, rawArgs)
 546	if err != nil {
 547		return nil, err
 548	}
 549	args["path"] = arg1
 550	arg2, err := ec.field_Repository_lastCommits_argsNames(ctx, rawArgs)
 551	if err != nil {
 552		return nil, err
 553	}
 554	args["names"] = arg2
 555	return args, nil
 556}
 557func (ec *executionContext) field_Repository_lastCommits_argsRef(
 558	ctx context.Context,
 559	rawArgs map[string]any,
 560) (string, error) {
 561	if _, ok := rawArgs["ref"]; !ok {
 562		var zeroVal string
 563		return zeroVal, nil
 564	}
 565
 566	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
 567	if tmp, ok := rawArgs["ref"]; ok {
 568		return ec.unmarshalNString2string(ctx, tmp)
 569	}
 570
 571	var zeroVal string
 572	return zeroVal, nil
 573}
 574
 575func (ec *executionContext) field_Repository_lastCommits_argsPath(
 576	ctx context.Context,
 577	rawArgs map[string]any,
 578) (*string, error) {
 579	if _, ok := rawArgs["path"]; !ok {
 580		var zeroVal *string
 581		return zeroVal, nil
 582	}
 583
 584	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))
 585	if tmp, ok := rawArgs["path"]; ok {
 586		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 587	}
 588
 589	var zeroVal *string
 590	return zeroVal, nil
 591}
 592
 593func (ec *executionContext) field_Repository_lastCommits_argsNames(
 594	ctx context.Context,
 595	rawArgs map[string]any,
 596) ([]string, error) {
 597	if _, ok := rawArgs["names"]; !ok {
 598		var zeroVal []string
 599		return zeroVal, nil
 600	}
 601
 602	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("names"))
 603	if tmp, ok := rawArgs["names"]; ok {
 604		return ec.unmarshalNString2ᚕstringᚄ(ctx, tmp)
 605	}
 606
 607	var zeroVal []string
 608	return zeroVal, nil
 609}
 610
 611func (ec *executionContext) field_Repository_refs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 612	var err error
 613	args := map[string]any{}
 614	arg0, err := ec.field_Repository_refs_argsAfter(ctx, rawArgs)
 615	if err != nil {
 616		return nil, err
 617	}
 618	args["after"] = arg0
 619	arg1, err := ec.field_Repository_refs_argsBefore(ctx, rawArgs)
 620	if err != nil {
 621		return nil, err
 622	}
 623	args["before"] = arg1
 624	arg2, err := ec.field_Repository_refs_argsFirst(ctx, rawArgs)
 625	if err != nil {
 626		return nil, err
 627	}
 628	args["first"] = arg2
 629	arg3, err := ec.field_Repository_refs_argsLast(ctx, rawArgs)
 630	if err != nil {
 631		return nil, err
 632	}
 633	args["last"] = arg3
 634	arg4, err := ec.field_Repository_refs_argsType(ctx, rawArgs)
 635	if err != nil {
 636		return nil, err
 637	}
 638	args["type"] = arg4
 639	return args, nil
 640}
 641func (ec *executionContext) field_Repository_refs_argsAfter(
 642	ctx context.Context,
 643	rawArgs map[string]any,
 644) (*string, error) {
 645	if _, ok := rawArgs["after"]; !ok {
 646		var zeroVal *string
 647		return zeroVal, nil
 648	}
 649
 650	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 651	if tmp, ok := rawArgs["after"]; ok {
 652		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 653	}
 654
 655	var zeroVal *string
 656	return zeroVal, nil
 657}
 658
 659func (ec *executionContext) field_Repository_refs_argsBefore(
 660	ctx context.Context,
 661	rawArgs map[string]any,
 662) (*string, error) {
 663	if _, ok := rawArgs["before"]; !ok {
 664		var zeroVal *string
 665		return zeroVal, nil
 666	}
 667
 668	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 669	if tmp, ok := rawArgs["before"]; ok {
 670		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 671	}
 672
 673	var zeroVal *string
 674	return zeroVal, nil
 675}
 676
 677func (ec *executionContext) field_Repository_refs_argsFirst(
 678	ctx context.Context,
 679	rawArgs map[string]any,
 680) (*int, error) {
 681	if _, ok := rawArgs["first"]; !ok {
 682		var zeroVal *int
 683		return zeroVal, nil
 684	}
 685
 686	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 687	if tmp, ok := rawArgs["first"]; ok {
 688		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 689	}
 690
 691	var zeroVal *int
 692	return zeroVal, nil
 693}
 694
 695func (ec *executionContext) field_Repository_refs_argsLast(
 696	ctx context.Context,
 697	rawArgs map[string]any,
 698) (*int, error) {
 699	if _, ok := rawArgs["last"]; !ok {
 700		var zeroVal *int
 701		return zeroVal, nil
 702	}
 703
 704	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 705	if tmp, ok := rawArgs["last"]; ok {
 706		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 707	}
 708
 709	var zeroVal *int
 710	return zeroVal, nil
 711}
 712
 713func (ec *executionContext) field_Repository_refs_argsType(
 714	ctx context.Context,
 715	rawArgs map[string]any,
 716) (*models.GitRefType, error) {
 717	if _, ok := rawArgs["type"]; !ok {
 718		var zeroVal *models.GitRefType
 719		return zeroVal, nil
 720	}
 721
 722	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
 723	if tmp, ok := rawArgs["type"]; ok {
 724		return ec.unmarshalOGitRefType2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefType(ctx, tmp)
 725	}
 726
 727	var zeroVal *models.GitRefType
 728	return zeroVal, nil
 729}
 730
 731func (ec *executionContext) field_Repository_tree_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 732	var err error
 733	args := map[string]any{}
 734	arg0, err := ec.field_Repository_tree_argsRef(ctx, rawArgs)
 735	if err != nil {
 736		return nil, err
 737	}
 738	args["ref"] = arg0
 739	arg1, err := ec.field_Repository_tree_argsPath(ctx, rawArgs)
 740	if err != nil {
 741		return nil, err
 742	}
 743	args["path"] = arg1
 744	return args, nil
 745}
 746func (ec *executionContext) field_Repository_tree_argsRef(
 747	ctx context.Context,
 748	rawArgs map[string]any,
 749) (string, error) {
 750	if _, ok := rawArgs["ref"]; !ok {
 751		var zeroVal string
 752		return zeroVal, nil
 753	}
 754
 755	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("ref"))
 756	if tmp, ok := rawArgs["ref"]; ok {
 757		return ec.unmarshalNString2string(ctx, tmp)
 758	}
 759
 760	var zeroVal string
 761	return zeroVal, nil
 762}
 763
 764func (ec *executionContext) field_Repository_tree_argsPath(
 765	ctx context.Context,
 766	rawArgs map[string]any,
 767) (*string, error) {
 768	if _, ok := rawArgs["path"]; !ok {
 769		var zeroVal *string
 770		return zeroVal, nil
 771	}
 772
 773	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))
 774	if tmp, ok := rawArgs["path"]; ok {
 775		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 776	}
 777
 778	var zeroVal *string
 779	return zeroVal, nil
 780}
 781
 782func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 783	var err error
 784	args := map[string]any{}
 785	arg0, err := ec.field_Repository_validLabels_argsAfter(ctx, rawArgs)
 786	if err != nil {
 787		return nil, err
 788	}
 789	args["after"] = arg0
 790	arg1, err := ec.field_Repository_validLabels_argsBefore(ctx, rawArgs)
 791	if err != nil {
 792		return nil, err
 793	}
 794	args["before"] = arg1
 795	arg2, err := ec.field_Repository_validLabels_argsFirst(ctx, rawArgs)
 796	if err != nil {
 797		return nil, err
 798	}
 799	args["first"] = arg2
 800	arg3, err := ec.field_Repository_validLabels_argsLast(ctx, rawArgs)
 801	if err != nil {
 802		return nil, err
 803	}
 804	args["last"] = arg3
 805	return args, nil
 806}
 807func (ec *executionContext) field_Repository_validLabels_argsAfter(
 808	ctx context.Context,
 809	rawArgs map[string]any,
 810) (*string, error) {
 811	if _, ok := rawArgs["after"]; !ok {
 812		var zeroVal *string
 813		return zeroVal, nil
 814	}
 815
 816	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 817	if tmp, ok := rawArgs["after"]; ok {
 818		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 819	}
 820
 821	var zeroVal *string
 822	return zeroVal, nil
 823}
 824
 825func (ec *executionContext) field_Repository_validLabels_argsBefore(
 826	ctx context.Context,
 827	rawArgs map[string]any,
 828) (*string, error) {
 829	if _, ok := rawArgs["before"]; !ok {
 830		var zeroVal *string
 831		return zeroVal, nil
 832	}
 833
 834	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 835	if tmp, ok := rawArgs["before"]; ok {
 836		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 837	}
 838
 839	var zeroVal *string
 840	return zeroVal, nil
 841}
 842
 843func (ec *executionContext) field_Repository_validLabels_argsFirst(
 844	ctx context.Context,
 845	rawArgs map[string]any,
 846) (*int, error) {
 847	if _, ok := rawArgs["first"]; !ok {
 848		var zeroVal *int
 849		return zeroVal, nil
 850	}
 851
 852	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 853	if tmp, ok := rawArgs["first"]; ok {
 854		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 855	}
 856
 857	var zeroVal *int
 858	return zeroVal, nil
 859}
 860
 861func (ec *executionContext) field_Repository_validLabels_argsLast(
 862	ctx context.Context,
 863	rawArgs map[string]any,
 864) (*int, error) {
 865	if _, ok := rawArgs["last"]; !ok {
 866		var zeroVal *int
 867		return zeroVal, nil
 868	}
 869
 870	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 871	if tmp, ok := rawArgs["last"]; ok {
 872		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 873	}
 874
 875	var zeroVal *int
 876	return zeroVal, nil
 877}
 878
 879// endregion ***************************** args.gotpl *****************************
 880
 881// region    ************************** directives.gotpl **************************
 882
 883// endregion ************************** directives.gotpl **************************
 884
 885// region    **************************** field.gotpl *****************************
 886
 887func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 888	fc, err := ec.fieldContext_Repository_name(ctx, field)
 889	if err != nil {
 890		return graphql.Null
 891	}
 892	ctx = graphql.WithFieldContext(ctx, fc)
 893	defer func() {
 894		if r := recover(); r != nil {
 895			ec.Error(ctx, ec.Recover(ctx, r))
 896			ret = graphql.Null
 897		}
 898	}()
 899	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 900		ctx = rctx // use context from middleware stack in children
 901		return ec.resolvers.Repository().Name(rctx, obj)
 902	})
 903	if err != nil {
 904		ec.Error(ctx, err)
 905		return graphql.Null
 906	}
 907	if resTmp == nil {
 908		return graphql.Null
 909	}
 910	res := resTmp.(*string)
 911	fc.Result = res
 912	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 913}
 914
 915func (ec *executionContext) fieldContext_Repository_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 916	fc = &graphql.FieldContext{
 917		Object:     "Repository",
 918		Field:      field,
 919		IsMethod:   true,
 920		IsResolver: true,
 921		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 922			return nil, errors.New("field of type String does not have child fields")
 923		},
 924	}
 925	return fc, nil
 926}
 927
 928func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 929	fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
 930	if err != nil {
 931		return graphql.Null
 932	}
 933	ctx = graphql.WithFieldContext(ctx, fc)
 934	defer func() {
 935		if r := recover(); r != nil {
 936			ec.Error(ctx, ec.Recover(ctx, r))
 937			ret = graphql.Null
 938		}
 939	}()
 940	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 941		ctx = rctx // use context from middleware stack in children
 942		return ec.resolvers.Repository().AllBugs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
 943	})
 944	if err != nil {
 945		ec.Error(ctx, err)
 946		return graphql.Null
 947	}
 948	if resTmp == nil {
 949		if !graphql.HasFieldError(ctx, fc) {
 950			ec.Errorf(ctx, "must not be null")
 951		}
 952		return graphql.Null
 953	}
 954	res := resTmp.(*models.BugConnection)
 955	fc.Result = res
 956	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 957}
 958
 959func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 960	fc = &graphql.FieldContext{
 961		Object:     "Repository",
 962		Field:      field,
 963		IsMethod:   true,
 964		IsResolver: true,
 965		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 966			switch field.Name {
 967			case "edges":
 968				return ec.fieldContext_BugConnection_edges(ctx, field)
 969			case "nodes":
 970				return ec.fieldContext_BugConnection_nodes(ctx, field)
 971			case "pageInfo":
 972				return ec.fieldContext_BugConnection_pageInfo(ctx, field)
 973			case "totalCount":
 974				return ec.fieldContext_BugConnection_totalCount(ctx, field)
 975			}
 976			return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
 977		},
 978	}
 979	defer func() {
 980		if r := recover(); r != nil {
 981			err = ec.Recover(ctx, r)
 982			ec.Error(ctx, err)
 983		}
 984	}()
 985	ctx = graphql.WithFieldContext(ctx, fc)
 986	if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 987		ec.Error(ctx, err)
 988		return fc, err
 989	}
 990	return fc, nil
 991}
 992
 993func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 994	fc, err := ec.fieldContext_Repository_bug(ctx, field)
 995	if err != nil {
 996		return graphql.Null
 997	}
 998	ctx = graphql.WithFieldContext(ctx, fc)
 999	defer func() {
1000		if r := recover(); r != nil {
1001			ec.Error(ctx, ec.Recover(ctx, r))
1002			ret = graphql.Null
1003		}
1004	}()
1005	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1006		ctx = rctx // use context from middleware stack in children
1007		return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
1008	})
1009	if err != nil {
1010		ec.Error(ctx, err)
1011		return graphql.Null
1012	}
1013	if resTmp == nil {
1014		return graphql.Null
1015	}
1016	res := resTmp.(models.BugWrapper)
1017	fc.Result = res
1018	return ec.marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
1019}
1020
1021func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1022	fc = &graphql.FieldContext{
1023		Object:     "Repository",
1024		Field:      field,
1025		IsMethod:   true,
1026		IsResolver: true,
1027		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1028			switch field.Name {
1029			case "id":
1030				return ec.fieldContext_Bug_id(ctx, field)
1031			case "humanId":
1032				return ec.fieldContext_Bug_humanId(ctx, field)
1033			case "status":
1034				return ec.fieldContext_Bug_status(ctx, field)
1035			case "title":
1036				return ec.fieldContext_Bug_title(ctx, field)
1037			case "labels":
1038				return ec.fieldContext_Bug_labels(ctx, field)
1039			case "author":
1040				return ec.fieldContext_Bug_author(ctx, field)
1041			case "createdAt":
1042				return ec.fieldContext_Bug_createdAt(ctx, field)
1043			case "lastEdit":
1044				return ec.fieldContext_Bug_lastEdit(ctx, field)
1045			case "actors":
1046				return ec.fieldContext_Bug_actors(ctx, field)
1047			case "participants":
1048				return ec.fieldContext_Bug_participants(ctx, field)
1049			case "comments":
1050				return ec.fieldContext_Bug_comments(ctx, field)
1051			case "timeline":
1052				return ec.fieldContext_Bug_timeline(ctx, field)
1053			case "operations":
1054				return ec.fieldContext_Bug_operations(ctx, field)
1055			}
1056			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
1057		},
1058	}
1059	defer func() {
1060		if r := recover(); r != nil {
1061			err = ec.Recover(ctx, r)
1062			ec.Error(ctx, err)
1063		}
1064	}()
1065	ctx = graphql.WithFieldContext(ctx, fc)
1066	if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1067		ec.Error(ctx, err)
1068		return fc, err
1069	}
1070	return fc, nil
1071}
1072
1073func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1074	fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
1075	if err != nil {
1076		return graphql.Null
1077	}
1078	ctx = graphql.WithFieldContext(ctx, fc)
1079	defer func() {
1080		if r := recover(); r != nil {
1081			ec.Error(ctx, ec.Recover(ctx, r))
1082			ret = graphql.Null
1083		}
1084	}()
1085	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1086		ctx = rctx // use context from middleware stack in children
1087		return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1088	})
1089	if err != nil {
1090		ec.Error(ctx, err)
1091		return graphql.Null
1092	}
1093	if resTmp == nil {
1094		if !graphql.HasFieldError(ctx, fc) {
1095			ec.Errorf(ctx, "must not be null")
1096		}
1097		return graphql.Null
1098	}
1099	res := resTmp.(*models.IdentityConnection)
1100	fc.Result = res
1101	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
1102}
1103
1104func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1105	fc = &graphql.FieldContext{
1106		Object:     "Repository",
1107		Field:      field,
1108		IsMethod:   true,
1109		IsResolver: true,
1110		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1111			switch field.Name {
1112			case "edges":
1113				return ec.fieldContext_IdentityConnection_edges(ctx, field)
1114			case "nodes":
1115				return ec.fieldContext_IdentityConnection_nodes(ctx, field)
1116			case "pageInfo":
1117				return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
1118			case "totalCount":
1119				return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
1120			}
1121			return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
1122		},
1123	}
1124	defer func() {
1125		if r := recover(); r != nil {
1126			err = ec.Recover(ctx, r)
1127			ec.Error(ctx, err)
1128		}
1129	}()
1130	ctx = graphql.WithFieldContext(ctx, fc)
1131	if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1132		ec.Error(ctx, err)
1133		return fc, err
1134	}
1135	return fc, nil
1136}
1137
1138func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1139	fc, err := ec.fieldContext_Repository_identity(ctx, field)
1140	if err != nil {
1141		return graphql.Null
1142	}
1143	ctx = graphql.WithFieldContext(ctx, fc)
1144	defer func() {
1145		if r := recover(); r != nil {
1146			ec.Error(ctx, ec.Recover(ctx, r))
1147			ret = graphql.Null
1148		}
1149	}()
1150	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1151		ctx = rctx // use context from middleware stack in children
1152		return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
1153	})
1154	if err != nil {
1155		ec.Error(ctx, err)
1156		return graphql.Null
1157	}
1158	if resTmp == nil {
1159		return graphql.Null
1160	}
1161	res := resTmp.(models.IdentityWrapper)
1162	fc.Result = res
1163	return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
1164}
1165
1166func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1167	fc = &graphql.FieldContext{
1168		Object:     "Repository",
1169		Field:      field,
1170		IsMethod:   true,
1171		IsResolver: true,
1172		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1173			switch field.Name {
1174			case "id":
1175				return ec.fieldContext_Identity_id(ctx, field)
1176			case "humanId":
1177				return ec.fieldContext_Identity_humanId(ctx, field)
1178			case "name":
1179				return ec.fieldContext_Identity_name(ctx, field)
1180			case "email":
1181				return ec.fieldContext_Identity_email(ctx, field)
1182			case "login":
1183				return ec.fieldContext_Identity_login(ctx, field)
1184			case "displayName":
1185				return ec.fieldContext_Identity_displayName(ctx, field)
1186			case "avatarUrl":
1187				return ec.fieldContext_Identity_avatarUrl(ctx, field)
1188			case "isProtected":
1189				return ec.fieldContext_Identity_isProtected(ctx, field)
1190			}
1191			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1192		},
1193	}
1194	defer func() {
1195		if r := recover(); r != nil {
1196			err = ec.Recover(ctx, r)
1197			ec.Error(ctx, err)
1198		}
1199	}()
1200	ctx = graphql.WithFieldContext(ctx, fc)
1201	if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1202		ec.Error(ctx, err)
1203		return fc, err
1204	}
1205	return fc, nil
1206}
1207
1208func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1209	fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
1210	if err != nil {
1211		return graphql.Null
1212	}
1213	ctx = graphql.WithFieldContext(ctx, fc)
1214	defer func() {
1215		if r := recover(); r != nil {
1216			ec.Error(ctx, ec.Recover(ctx, r))
1217			ret = graphql.Null
1218		}
1219	}()
1220	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1221		ctx = rctx // use context from middleware stack in children
1222		return ec.resolvers.Repository().UserIdentity(rctx, obj)
1223	})
1224	if err != nil {
1225		ec.Error(ctx, err)
1226		return graphql.Null
1227	}
1228	if resTmp == nil {
1229		return graphql.Null
1230	}
1231	res := resTmp.(models.IdentityWrapper)
1232	fc.Result = res
1233	return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
1234}
1235
1236func (ec *executionContext) fieldContext_Repository_userIdentity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1237	fc = &graphql.FieldContext{
1238		Object:     "Repository",
1239		Field:      field,
1240		IsMethod:   true,
1241		IsResolver: true,
1242		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1243			switch field.Name {
1244			case "id":
1245				return ec.fieldContext_Identity_id(ctx, field)
1246			case "humanId":
1247				return ec.fieldContext_Identity_humanId(ctx, field)
1248			case "name":
1249				return ec.fieldContext_Identity_name(ctx, field)
1250			case "email":
1251				return ec.fieldContext_Identity_email(ctx, field)
1252			case "login":
1253				return ec.fieldContext_Identity_login(ctx, field)
1254			case "displayName":
1255				return ec.fieldContext_Identity_displayName(ctx, field)
1256			case "avatarUrl":
1257				return ec.fieldContext_Identity_avatarUrl(ctx, field)
1258			case "isProtected":
1259				return ec.fieldContext_Identity_isProtected(ctx, field)
1260			}
1261			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
1262		},
1263	}
1264	return fc, nil
1265}
1266
1267func (ec *executionContext) _Repository_refs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1268	fc, err := ec.fieldContext_Repository_refs(ctx, field)
1269	if err != nil {
1270		return graphql.Null
1271	}
1272	ctx = graphql.WithFieldContext(ctx, fc)
1273	defer func() {
1274		if r := recover(); r != nil {
1275			ec.Error(ctx, ec.Recover(ctx, r))
1276			ret = graphql.Null
1277		}
1278	}()
1279	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1280		ctx = rctx // use context from middleware stack in children
1281		return ec.resolvers.Repository().Refs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["type"].(*models.GitRefType))
1282	})
1283	if err != nil {
1284		ec.Error(ctx, err)
1285		return graphql.Null
1286	}
1287	if resTmp == nil {
1288		if !graphql.HasFieldError(ctx, fc) {
1289			ec.Errorf(ctx, "must not be null")
1290		}
1291		return graphql.Null
1292	}
1293	res := resTmp.(*models.GitRefConnection)
1294	fc.Result = res
1295	return ec.marshalNGitRefConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitRefConnection(ctx, field.Selections, res)
1296}
1297
1298func (ec *executionContext) fieldContext_Repository_refs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1299	fc = &graphql.FieldContext{
1300		Object:     "Repository",
1301		Field:      field,
1302		IsMethod:   true,
1303		IsResolver: true,
1304		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1305			switch field.Name {
1306			case "nodes":
1307				return ec.fieldContext_GitRefConnection_nodes(ctx, field)
1308			case "pageInfo":
1309				return ec.fieldContext_GitRefConnection_pageInfo(ctx, field)
1310			case "totalCount":
1311				return ec.fieldContext_GitRefConnection_totalCount(ctx, field)
1312			}
1313			return nil, fmt.Errorf("no field named %q was found under type GitRefConnection", field.Name)
1314		},
1315	}
1316	defer func() {
1317		if r := recover(); r != nil {
1318			err = ec.Recover(ctx, r)
1319			ec.Error(ctx, err)
1320		}
1321	}()
1322	ctx = graphql.WithFieldContext(ctx, fc)
1323	if fc.Args, err = ec.field_Repository_refs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1324		ec.Error(ctx, err)
1325		return fc, err
1326	}
1327	return fc, nil
1328}
1329
1330func (ec *executionContext) _Repository_tree(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1331	fc, err := ec.fieldContext_Repository_tree(ctx, field)
1332	if err != nil {
1333		return graphql.Null
1334	}
1335	ctx = graphql.WithFieldContext(ctx, fc)
1336	defer func() {
1337		if r := recover(); r != nil {
1338			ec.Error(ctx, ec.Recover(ctx, r))
1339			ret = graphql.Null
1340		}
1341	}()
1342	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1343		ctx = rctx // use context from middleware stack in children
1344		return ec.resolvers.Repository().Tree(rctx, obj, fc.Args["ref"].(string), fc.Args["path"].(*string))
1345	})
1346	if err != nil {
1347		ec.Error(ctx, err)
1348		return graphql.Null
1349	}
1350	if resTmp == nil {
1351		if !graphql.HasFieldError(ctx, fc) {
1352			ec.Errorf(ctx, "must not be null")
1353		}
1354		return graphql.Null
1355	}
1356	res := resTmp.([]*repository.TreeEntry)
1357	fc.Result = res
1358	return ec.marshalNGitTreeEntry2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐTreeEntryᚄ(ctx, field.Selections, res)
1359}
1360
1361func (ec *executionContext) fieldContext_Repository_tree(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1362	fc = &graphql.FieldContext{
1363		Object:     "Repository",
1364		Field:      field,
1365		IsMethod:   true,
1366		IsResolver: true,
1367		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1368			switch field.Name {
1369			case "name":
1370				return ec.fieldContext_GitTreeEntry_name(ctx, field)
1371			case "type":
1372				return ec.fieldContext_GitTreeEntry_type(ctx, field)
1373			case "hash":
1374				return ec.fieldContext_GitTreeEntry_hash(ctx, field)
1375			}
1376			return nil, fmt.Errorf("no field named %q was found under type GitTreeEntry", field.Name)
1377		},
1378	}
1379	defer func() {
1380		if r := recover(); r != nil {
1381			err = ec.Recover(ctx, r)
1382			ec.Error(ctx, err)
1383		}
1384	}()
1385	ctx = graphql.WithFieldContext(ctx, fc)
1386	if fc.Args, err = ec.field_Repository_tree_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1387		ec.Error(ctx, err)
1388		return fc, err
1389	}
1390	return fc, nil
1391}
1392
1393func (ec *executionContext) _Repository_blob(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1394	fc, err := ec.fieldContext_Repository_blob(ctx, field)
1395	if err != nil {
1396		return graphql.Null
1397	}
1398	ctx = graphql.WithFieldContext(ctx, fc)
1399	defer func() {
1400		if r := recover(); r != nil {
1401			ec.Error(ctx, ec.Recover(ctx, r))
1402			ret = graphql.Null
1403		}
1404	}()
1405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1406		ctx = rctx // use context from middleware stack in children
1407		return ec.resolvers.Repository().Blob(rctx, obj, fc.Args["ref"].(string), fc.Args["path"].(string))
1408	})
1409	if err != nil {
1410		ec.Error(ctx, err)
1411		return graphql.Null
1412	}
1413	if resTmp == nil {
1414		return graphql.Null
1415	}
1416	res := resTmp.(*models.GitBlob)
1417	fc.Result = res
1418	return ec.marshalOGitBlob2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitBlob(ctx, field.Selections, res)
1419}
1420
1421func (ec *executionContext) fieldContext_Repository_blob(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1422	fc = &graphql.FieldContext{
1423		Object:     "Repository",
1424		Field:      field,
1425		IsMethod:   true,
1426		IsResolver: true,
1427		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1428			switch field.Name {
1429			case "path":
1430				return ec.fieldContext_GitBlob_path(ctx, field)
1431			case "hash":
1432				return ec.fieldContext_GitBlob_hash(ctx, field)
1433			case "text":
1434				return ec.fieldContext_GitBlob_text(ctx, field)
1435			case "size":
1436				return ec.fieldContext_GitBlob_size(ctx, field)
1437			case "isBinary":
1438				return ec.fieldContext_GitBlob_isBinary(ctx, field)
1439			case "isTruncated":
1440				return ec.fieldContext_GitBlob_isTruncated(ctx, field)
1441			}
1442			return nil, fmt.Errorf("no field named %q was found under type GitBlob", field.Name)
1443		},
1444	}
1445	defer func() {
1446		if r := recover(); r != nil {
1447			err = ec.Recover(ctx, r)
1448			ec.Error(ctx, err)
1449		}
1450	}()
1451	ctx = graphql.WithFieldContext(ctx, fc)
1452	if fc.Args, err = ec.field_Repository_blob_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1453		ec.Error(ctx, err)
1454		return fc, err
1455	}
1456	return fc, nil
1457}
1458
1459func (ec *executionContext) _Repository_commits(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1460	fc, err := ec.fieldContext_Repository_commits(ctx, field)
1461	if err != nil {
1462		return graphql.Null
1463	}
1464	ctx = graphql.WithFieldContext(ctx, fc)
1465	defer func() {
1466		if r := recover(); r != nil {
1467			ec.Error(ctx, ec.Recover(ctx, r))
1468			ret = graphql.Null
1469		}
1470	}()
1471	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1472		ctx = rctx // use context from middleware stack in children
1473		return ec.resolvers.Repository().Commits(rctx, obj, fc.Args["after"].(*string), fc.Args["first"].(*int), fc.Args["ref"].(string), fc.Args["path"].(*string), fc.Args["since"].(*time.Time), fc.Args["until"].(*time.Time))
1474	})
1475	if err != nil {
1476		ec.Error(ctx, err)
1477		return graphql.Null
1478	}
1479	if resTmp == nil {
1480		if !graphql.HasFieldError(ctx, fc) {
1481			ec.Errorf(ctx, "must not be null")
1482		}
1483		return graphql.Null
1484	}
1485	res := resTmp.(*models.GitCommitConnection)
1486	fc.Result = res
1487	return ec.marshalNGitCommitConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitConnection(ctx, field.Selections, res)
1488}
1489
1490func (ec *executionContext) fieldContext_Repository_commits(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1491	fc = &graphql.FieldContext{
1492		Object:     "Repository",
1493		Field:      field,
1494		IsMethod:   true,
1495		IsResolver: true,
1496		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1497			switch field.Name {
1498			case "nodes":
1499				return ec.fieldContext_GitCommitConnection_nodes(ctx, field)
1500			case "pageInfo":
1501				return ec.fieldContext_GitCommitConnection_pageInfo(ctx, field)
1502			case "totalCount":
1503				return ec.fieldContext_GitCommitConnection_totalCount(ctx, field)
1504			}
1505			return nil, fmt.Errorf("no field named %q was found under type GitCommitConnection", field.Name)
1506		},
1507	}
1508	defer func() {
1509		if r := recover(); r != nil {
1510			err = ec.Recover(ctx, r)
1511			ec.Error(ctx, err)
1512		}
1513	}()
1514	ctx = graphql.WithFieldContext(ctx, fc)
1515	if fc.Args, err = ec.field_Repository_commits_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1516		ec.Error(ctx, err)
1517		return fc, err
1518	}
1519	return fc, nil
1520}
1521
1522func (ec *executionContext) _Repository_commit(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1523	fc, err := ec.fieldContext_Repository_commit(ctx, field)
1524	if err != nil {
1525		return graphql.Null
1526	}
1527	ctx = graphql.WithFieldContext(ctx, fc)
1528	defer func() {
1529		if r := recover(); r != nil {
1530			ec.Error(ctx, ec.Recover(ctx, r))
1531			ret = graphql.Null
1532		}
1533	}()
1534	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1535		ctx = rctx // use context from middleware stack in children
1536		return ec.resolvers.Repository().Commit(rctx, obj, fc.Args["hash"].(string))
1537	})
1538	if err != nil {
1539		ec.Error(ctx, err)
1540		return graphql.Null
1541	}
1542	if resTmp == nil {
1543		return graphql.Null
1544	}
1545	res := resTmp.(*models.GitCommitMeta)
1546	fc.Result = res
1547	return ec.marshalOGitCommit2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitCommitMeta(ctx, field.Selections, res)
1548}
1549
1550func (ec *executionContext) fieldContext_Repository_commit(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1551	fc = &graphql.FieldContext{
1552		Object:     "Repository",
1553		Field:      field,
1554		IsMethod:   true,
1555		IsResolver: true,
1556		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1557			switch field.Name {
1558			case "hash":
1559				return ec.fieldContext_GitCommit_hash(ctx, field)
1560			case "shortHash":
1561				return ec.fieldContext_GitCommit_shortHash(ctx, field)
1562			case "message":
1563				return ec.fieldContext_GitCommit_message(ctx, field)
1564			case "fullMessage":
1565				return ec.fieldContext_GitCommit_fullMessage(ctx, field)
1566			case "authorName":
1567				return ec.fieldContext_GitCommit_authorName(ctx, field)
1568			case "authorEmail":
1569				return ec.fieldContext_GitCommit_authorEmail(ctx, field)
1570			case "date":
1571				return ec.fieldContext_GitCommit_date(ctx, field)
1572			case "parents":
1573				return ec.fieldContext_GitCommit_parents(ctx, field)
1574			case "files":
1575				return ec.fieldContext_GitCommit_files(ctx, field)
1576			case "diff":
1577				return ec.fieldContext_GitCommit_diff(ctx, field)
1578			}
1579			return nil, fmt.Errorf("no field named %q was found under type GitCommit", field.Name)
1580		},
1581	}
1582	defer func() {
1583		if r := recover(); r != nil {
1584			err = ec.Recover(ctx, r)
1585			ec.Error(ctx, err)
1586		}
1587	}()
1588	ctx = graphql.WithFieldContext(ctx, fc)
1589	if fc.Args, err = ec.field_Repository_commit_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1590		ec.Error(ctx, err)
1591		return fc, err
1592	}
1593	return fc, nil
1594}
1595
1596func (ec *executionContext) _Repository_lastCommits(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1597	fc, err := ec.fieldContext_Repository_lastCommits(ctx, field)
1598	if err != nil {
1599		return graphql.Null
1600	}
1601	ctx = graphql.WithFieldContext(ctx, fc)
1602	defer func() {
1603		if r := recover(); r != nil {
1604			ec.Error(ctx, ec.Recover(ctx, r))
1605			ret = graphql.Null
1606		}
1607	}()
1608	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1609		ctx = rctx // use context from middleware stack in children
1610		return ec.resolvers.Repository().LastCommits(rctx, obj, fc.Args["ref"].(string), fc.Args["path"].(*string), fc.Args["names"].([]string))
1611	})
1612	if err != nil {
1613		ec.Error(ctx, err)
1614		return graphql.Null
1615	}
1616	if resTmp == nil {
1617		if !graphql.HasFieldError(ctx, fc) {
1618			ec.Errorf(ctx, "must not be null")
1619		}
1620		return graphql.Null
1621	}
1622	res := resTmp.([]*models.GitLastCommit)
1623	fc.Result = res
1624	return ec.marshalNGitLastCommit2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐGitLastCommitᚄ(ctx, field.Selections, res)
1625}
1626
1627func (ec *executionContext) fieldContext_Repository_lastCommits(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1628	fc = &graphql.FieldContext{
1629		Object:     "Repository",
1630		Field:      field,
1631		IsMethod:   true,
1632		IsResolver: true,
1633		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1634			switch field.Name {
1635			case "name":
1636				return ec.fieldContext_GitLastCommit_name(ctx, field)
1637			case "commit":
1638				return ec.fieldContext_GitLastCommit_commit(ctx, field)
1639			}
1640			return nil, fmt.Errorf("no field named %q was found under type GitLastCommit", field.Name)
1641		},
1642	}
1643	defer func() {
1644		if r := recover(); r != nil {
1645			err = ec.Recover(ctx, r)
1646			ec.Error(ctx, err)
1647		}
1648	}()
1649	ctx = graphql.WithFieldContext(ctx, fc)
1650	if fc.Args, err = ec.field_Repository_lastCommits_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1651		ec.Error(ctx, err)
1652		return fc, err
1653	}
1654	return fc, nil
1655}
1656
1657func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
1658	fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
1659	if err != nil {
1660		return graphql.Null
1661	}
1662	ctx = graphql.WithFieldContext(ctx, fc)
1663	defer func() {
1664		if r := recover(); r != nil {
1665			ec.Error(ctx, ec.Recover(ctx, r))
1666			ret = graphql.Null
1667		}
1668	}()
1669	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1670		ctx = rctx // use context from middleware stack in children
1671		return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1672	})
1673	if err != nil {
1674		ec.Error(ctx, err)
1675		return graphql.Null
1676	}
1677	if resTmp == nil {
1678		if !graphql.HasFieldError(ctx, fc) {
1679			ec.Errorf(ctx, "must not be null")
1680		}
1681		return graphql.Null
1682	}
1683	res := resTmp.(*models.LabelConnection)
1684	fc.Result = res
1685	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
1686}
1687
1688func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1689	fc = &graphql.FieldContext{
1690		Object:     "Repository",
1691		Field:      field,
1692		IsMethod:   true,
1693		IsResolver: true,
1694		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1695			switch field.Name {
1696			case "edges":
1697				return ec.fieldContext_LabelConnection_edges(ctx, field)
1698			case "nodes":
1699				return ec.fieldContext_LabelConnection_nodes(ctx, field)
1700			case "pageInfo":
1701				return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
1702			case "totalCount":
1703				return ec.fieldContext_LabelConnection_totalCount(ctx, field)
1704			}
1705			return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
1706		},
1707	}
1708	defer func() {
1709		if r := recover(); r != nil {
1710			err = ec.Recover(ctx, r)
1711			ec.Error(ctx, err)
1712		}
1713	}()
1714	ctx = graphql.WithFieldContext(ctx, fc)
1715	if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1716		ec.Error(ctx, err)
1717		return fc, err
1718	}
1719	return fc, nil
1720}
1721
1722func (ec *executionContext) _RepositoryConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
1723	fc, err := ec.fieldContext_RepositoryConnection_edges(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.Edges, 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.([]*models.RepositoryEdge)
1749	fc.Result = res
1750	return ec.marshalNRepositoryEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdgeᚄ(ctx, field.Selections, res)
1751}
1752
1753func (ec *executionContext) fieldContext_RepositoryConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1754	fc = &graphql.FieldContext{
1755		Object:     "RepositoryConnection",
1756		Field:      field,
1757		IsMethod:   false,
1758		IsResolver: false,
1759		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1760			switch field.Name {
1761			case "cursor":
1762				return ec.fieldContext_RepositoryEdge_cursor(ctx, field)
1763			case "node":
1764				return ec.fieldContext_RepositoryEdge_node(ctx, field)
1765			}
1766			return nil, fmt.Errorf("no field named %q was found under type RepositoryEdge", field.Name)
1767		},
1768	}
1769	return fc, nil
1770}
1771
1772func (ec *executionContext) _RepositoryConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
1773	fc, err := ec.fieldContext_RepositoryConnection_nodes(ctx, field)
1774	if err != nil {
1775		return graphql.Null
1776	}
1777	ctx = graphql.WithFieldContext(ctx, fc)
1778	defer func() {
1779		if r := recover(); r != nil {
1780			ec.Error(ctx, ec.Recover(ctx, r))
1781			ret = graphql.Null
1782		}
1783	}()
1784	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1785		ctx = rctx // use context from middleware stack in children
1786		return obj.Nodes, nil
1787	})
1788	if err != nil {
1789		ec.Error(ctx, err)
1790		return graphql.Null
1791	}
1792	if resTmp == nil {
1793		if !graphql.HasFieldError(ctx, fc) {
1794			ec.Errorf(ctx, "must not be null")
1795		}
1796		return graphql.Null
1797	}
1798	res := resTmp.([]*models.Repository)
1799	fc.Result = res
1800	return ec.marshalNRepository2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryᚄ(ctx, field.Selections, res)
1801}
1802
1803func (ec *executionContext) fieldContext_RepositoryConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1804	fc = &graphql.FieldContext{
1805		Object:     "RepositoryConnection",
1806		Field:      field,
1807		IsMethod:   false,
1808		IsResolver: false,
1809		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1810			switch field.Name {
1811			case "name":
1812				return ec.fieldContext_Repository_name(ctx, field)
1813			case "allBugs":
1814				return ec.fieldContext_Repository_allBugs(ctx, field)
1815			case "bug":
1816				return ec.fieldContext_Repository_bug(ctx, field)
1817			case "allIdentities":
1818				return ec.fieldContext_Repository_allIdentities(ctx, field)
1819			case "identity":
1820				return ec.fieldContext_Repository_identity(ctx, field)
1821			case "userIdentity":
1822				return ec.fieldContext_Repository_userIdentity(ctx, field)
1823			case "refs":
1824				return ec.fieldContext_Repository_refs(ctx, field)
1825			case "tree":
1826				return ec.fieldContext_Repository_tree(ctx, field)
1827			case "blob":
1828				return ec.fieldContext_Repository_blob(ctx, field)
1829			case "commits":
1830				return ec.fieldContext_Repository_commits(ctx, field)
1831			case "commit":
1832				return ec.fieldContext_Repository_commit(ctx, field)
1833			case "lastCommits":
1834				return ec.fieldContext_Repository_lastCommits(ctx, field)
1835			case "validLabels":
1836				return ec.fieldContext_Repository_validLabels(ctx, field)
1837			}
1838			return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
1839		},
1840	}
1841	return fc, nil
1842}
1843
1844func (ec *executionContext) _RepositoryConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
1845	fc, err := ec.fieldContext_RepositoryConnection_pageInfo(ctx, field)
1846	if err != nil {
1847		return graphql.Null
1848	}
1849	ctx = graphql.WithFieldContext(ctx, fc)
1850	defer func() {
1851		if r := recover(); r != nil {
1852			ec.Error(ctx, ec.Recover(ctx, r))
1853			ret = graphql.Null
1854		}
1855	}()
1856	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1857		ctx = rctx // use context from middleware stack in children
1858		return obj.PageInfo, nil
1859	})
1860	if err != nil {
1861		ec.Error(ctx, err)
1862		return graphql.Null
1863	}
1864	if resTmp == nil {
1865		if !graphql.HasFieldError(ctx, fc) {
1866			ec.Errorf(ctx, "must not be null")
1867		}
1868		return graphql.Null
1869	}
1870	res := resTmp.(*models.PageInfo)
1871	fc.Result = res
1872	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
1873}
1874
1875func (ec *executionContext) fieldContext_RepositoryConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1876	fc = &graphql.FieldContext{
1877		Object:     "RepositoryConnection",
1878		Field:      field,
1879		IsMethod:   false,
1880		IsResolver: false,
1881		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1882			switch field.Name {
1883			case "hasNextPage":
1884				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
1885			case "hasPreviousPage":
1886				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
1887			case "startCursor":
1888				return ec.fieldContext_PageInfo_startCursor(ctx, field)
1889			case "endCursor":
1890				return ec.fieldContext_PageInfo_endCursor(ctx, field)
1891			}
1892			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
1893		},
1894	}
1895	return fc, nil
1896}
1897
1898func (ec *executionContext) _RepositoryConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
1899	fc, err := ec.fieldContext_RepositoryConnection_totalCount(ctx, field)
1900	if err != nil {
1901		return graphql.Null
1902	}
1903	ctx = graphql.WithFieldContext(ctx, fc)
1904	defer func() {
1905		if r := recover(); r != nil {
1906			ec.Error(ctx, ec.Recover(ctx, r))
1907			ret = graphql.Null
1908		}
1909	}()
1910	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1911		ctx = rctx // use context from middleware stack in children
1912		return obj.TotalCount, nil
1913	})
1914	if err != nil {
1915		ec.Error(ctx, err)
1916		return graphql.Null
1917	}
1918	if resTmp == nil {
1919		if !graphql.HasFieldError(ctx, fc) {
1920			ec.Errorf(ctx, "must not be null")
1921		}
1922		return graphql.Null
1923	}
1924	res := resTmp.(int)
1925	fc.Result = res
1926	return ec.marshalNInt2int(ctx, field.Selections, res)
1927}
1928
1929func (ec *executionContext) fieldContext_RepositoryConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1930	fc = &graphql.FieldContext{
1931		Object:     "RepositoryConnection",
1932		Field:      field,
1933		IsMethod:   false,
1934		IsResolver: false,
1935		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1936			return nil, errors.New("field of type Int does not have child fields")
1937		},
1938	}
1939	return fc, nil
1940}
1941
1942func (ec *executionContext) _RepositoryEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryEdge) (ret graphql.Marshaler) {
1943	fc, err := ec.fieldContext_RepositoryEdge_cursor(ctx, field)
1944	if err != nil {
1945		return graphql.Null
1946	}
1947	ctx = graphql.WithFieldContext(ctx, fc)
1948	defer func() {
1949		if r := recover(); r != nil {
1950			ec.Error(ctx, ec.Recover(ctx, r))
1951			ret = graphql.Null
1952		}
1953	}()
1954	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1955		ctx = rctx // use context from middleware stack in children
1956		return obj.Cursor, nil
1957	})
1958	if err != nil {
1959		ec.Error(ctx, err)
1960		return graphql.Null
1961	}
1962	if resTmp == nil {
1963		if !graphql.HasFieldError(ctx, fc) {
1964			ec.Errorf(ctx, "must not be null")
1965		}
1966		return graphql.Null
1967	}
1968	res := resTmp.(string)
1969	fc.Result = res
1970	return ec.marshalNString2string(ctx, field.Selections, res)
1971}
1972
1973func (ec *executionContext) fieldContext_RepositoryEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1974	fc = &graphql.FieldContext{
1975		Object:     "RepositoryEdge",
1976		Field:      field,
1977		IsMethod:   false,
1978		IsResolver: false,
1979		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1980			return nil, errors.New("field of type String does not have child fields")
1981		},
1982	}
1983	return fc, nil
1984}
1985
1986func (ec *executionContext) _RepositoryEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryEdge) (ret graphql.Marshaler) {
1987	fc, err := ec.fieldContext_RepositoryEdge_node(ctx, field)
1988	if err != nil {
1989		return graphql.Null
1990	}
1991	ctx = graphql.WithFieldContext(ctx, fc)
1992	defer func() {
1993		if r := recover(); r != nil {
1994			ec.Error(ctx, ec.Recover(ctx, r))
1995			ret = graphql.Null
1996		}
1997	}()
1998	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1999		ctx = rctx // use context from middleware stack in children
2000		return obj.Node, nil
2001	})
2002	if err != nil {
2003		ec.Error(ctx, err)
2004		return graphql.Null
2005	}
2006	if resTmp == nil {
2007		if !graphql.HasFieldError(ctx, fc) {
2008			ec.Errorf(ctx, "must not be null")
2009		}
2010		return graphql.Null
2011	}
2012	res := resTmp.(*models.Repository)
2013	fc.Result = res
2014	return ec.marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
2015}
2016
2017func (ec *executionContext) fieldContext_RepositoryEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
2018	fc = &graphql.FieldContext{
2019		Object:     "RepositoryEdge",
2020		Field:      field,
2021		IsMethod:   false,
2022		IsResolver: false,
2023		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
2024			switch field.Name {
2025			case "name":
2026				return ec.fieldContext_Repository_name(ctx, field)
2027			case "allBugs":
2028				return ec.fieldContext_Repository_allBugs(ctx, field)
2029			case "bug":
2030				return ec.fieldContext_Repository_bug(ctx, field)
2031			case "allIdentities":
2032				return ec.fieldContext_Repository_allIdentities(ctx, field)
2033			case "identity":
2034				return ec.fieldContext_Repository_identity(ctx, field)
2035			case "userIdentity":
2036				return ec.fieldContext_Repository_userIdentity(ctx, field)
2037			case "refs":
2038				return ec.fieldContext_Repository_refs(ctx, field)
2039			case "tree":
2040				return ec.fieldContext_Repository_tree(ctx, field)
2041			case "blob":
2042				return ec.fieldContext_Repository_blob(ctx, field)
2043			case "commits":
2044				return ec.fieldContext_Repository_commits(ctx, field)
2045			case "commit":
2046				return ec.fieldContext_Repository_commit(ctx, field)
2047			case "lastCommits":
2048				return ec.fieldContext_Repository_lastCommits(ctx, field)
2049			case "validLabels":
2050				return ec.fieldContext_Repository_validLabels(ctx, field)
2051			}
2052			return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
2053		},
2054	}
2055	return fc, nil
2056}
2057
2058// endregion **************************** field.gotpl *****************************
2059
2060// region    **************************** input.gotpl *****************************
2061
2062// endregion **************************** input.gotpl *****************************
2063
2064// region    ************************** interface.gotpl ***************************
2065
2066// endregion ************************** interface.gotpl ***************************
2067
2068// region    **************************** object.gotpl ****************************
2069
2070var repositoryImplementors = []string{"Repository"}
2071
2072func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
2073	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
2074
2075	out := graphql.NewFieldSet(fields)
2076	deferred := make(map[string]*graphql.FieldSet)
2077	for i, field := range fields {
2078		switch field.Name {
2079		case "__typename":
2080			out.Values[i] = graphql.MarshalString("Repository")
2081		case "name":
2082			field := field
2083
2084			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2085				defer func() {
2086					if r := recover(); r != nil {
2087						ec.Error(ctx, ec.Recover(ctx, r))
2088					}
2089				}()
2090				res = ec._Repository_name(ctx, field, obj)
2091				return res
2092			}
2093
2094			if field.Deferrable != nil {
2095				dfs, ok := deferred[field.Deferrable.Label]
2096				di := 0
2097				if ok {
2098					dfs.AddField(field)
2099					di = len(dfs.Values) - 1
2100				} else {
2101					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2102					deferred[field.Deferrable.Label] = dfs
2103				}
2104				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2105					return innerFunc(ctx, dfs)
2106				})
2107
2108				// don't run the out.Concurrently() call below
2109				out.Values[i] = graphql.Null
2110				continue
2111			}
2112
2113			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2114		case "allBugs":
2115			field := field
2116
2117			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2118				defer func() {
2119					if r := recover(); r != nil {
2120						ec.Error(ctx, ec.Recover(ctx, r))
2121					}
2122				}()
2123				res = ec._Repository_allBugs(ctx, field, obj)
2124				if res == graphql.Null {
2125					atomic.AddUint32(&fs.Invalids, 1)
2126				}
2127				return res
2128			}
2129
2130			if field.Deferrable != nil {
2131				dfs, ok := deferred[field.Deferrable.Label]
2132				di := 0
2133				if ok {
2134					dfs.AddField(field)
2135					di = len(dfs.Values) - 1
2136				} else {
2137					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2138					deferred[field.Deferrable.Label] = dfs
2139				}
2140				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2141					return innerFunc(ctx, dfs)
2142				})
2143
2144				// don't run the out.Concurrently() call below
2145				out.Values[i] = graphql.Null
2146				continue
2147			}
2148
2149			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2150		case "bug":
2151			field := field
2152
2153			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2154				defer func() {
2155					if r := recover(); r != nil {
2156						ec.Error(ctx, ec.Recover(ctx, r))
2157					}
2158				}()
2159				res = ec._Repository_bug(ctx, field, obj)
2160				return res
2161			}
2162
2163			if field.Deferrable != nil {
2164				dfs, ok := deferred[field.Deferrable.Label]
2165				di := 0
2166				if ok {
2167					dfs.AddField(field)
2168					di = len(dfs.Values) - 1
2169				} else {
2170					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2171					deferred[field.Deferrable.Label] = dfs
2172				}
2173				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2174					return innerFunc(ctx, dfs)
2175				})
2176
2177				// don't run the out.Concurrently() call below
2178				out.Values[i] = graphql.Null
2179				continue
2180			}
2181
2182			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2183		case "allIdentities":
2184			field := field
2185
2186			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2187				defer func() {
2188					if r := recover(); r != nil {
2189						ec.Error(ctx, ec.Recover(ctx, r))
2190					}
2191				}()
2192				res = ec._Repository_allIdentities(ctx, field, obj)
2193				if res == graphql.Null {
2194					atomic.AddUint32(&fs.Invalids, 1)
2195				}
2196				return res
2197			}
2198
2199			if field.Deferrable != nil {
2200				dfs, ok := deferred[field.Deferrable.Label]
2201				di := 0
2202				if ok {
2203					dfs.AddField(field)
2204					di = len(dfs.Values) - 1
2205				} else {
2206					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2207					deferred[field.Deferrable.Label] = dfs
2208				}
2209				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2210					return innerFunc(ctx, dfs)
2211				})
2212
2213				// don't run the out.Concurrently() call below
2214				out.Values[i] = graphql.Null
2215				continue
2216			}
2217
2218			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2219		case "identity":
2220			field := field
2221
2222			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2223				defer func() {
2224					if r := recover(); r != nil {
2225						ec.Error(ctx, ec.Recover(ctx, r))
2226					}
2227				}()
2228				res = ec._Repository_identity(ctx, field, obj)
2229				return res
2230			}
2231
2232			if field.Deferrable != nil {
2233				dfs, ok := deferred[field.Deferrable.Label]
2234				di := 0
2235				if ok {
2236					dfs.AddField(field)
2237					di = len(dfs.Values) - 1
2238				} else {
2239					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2240					deferred[field.Deferrable.Label] = dfs
2241				}
2242				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2243					return innerFunc(ctx, dfs)
2244				})
2245
2246				// don't run the out.Concurrently() call below
2247				out.Values[i] = graphql.Null
2248				continue
2249			}
2250
2251			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2252		case "userIdentity":
2253			field := field
2254
2255			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2256				defer func() {
2257					if r := recover(); r != nil {
2258						ec.Error(ctx, ec.Recover(ctx, r))
2259					}
2260				}()
2261				res = ec._Repository_userIdentity(ctx, field, obj)
2262				return res
2263			}
2264
2265			if field.Deferrable != nil {
2266				dfs, ok := deferred[field.Deferrable.Label]
2267				di := 0
2268				if ok {
2269					dfs.AddField(field)
2270					di = len(dfs.Values) - 1
2271				} else {
2272					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2273					deferred[field.Deferrable.Label] = dfs
2274				}
2275				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2276					return innerFunc(ctx, dfs)
2277				})
2278
2279				// don't run the out.Concurrently() call below
2280				out.Values[i] = graphql.Null
2281				continue
2282			}
2283
2284			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2285		case "refs":
2286			field := field
2287
2288			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2289				defer func() {
2290					if r := recover(); r != nil {
2291						ec.Error(ctx, ec.Recover(ctx, r))
2292					}
2293				}()
2294				res = ec._Repository_refs(ctx, field, obj)
2295				if res == graphql.Null {
2296					atomic.AddUint32(&fs.Invalids, 1)
2297				}
2298				return res
2299			}
2300
2301			if field.Deferrable != nil {
2302				dfs, ok := deferred[field.Deferrable.Label]
2303				di := 0
2304				if ok {
2305					dfs.AddField(field)
2306					di = len(dfs.Values) - 1
2307				} else {
2308					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2309					deferred[field.Deferrable.Label] = dfs
2310				}
2311				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2312					return innerFunc(ctx, dfs)
2313				})
2314
2315				// don't run the out.Concurrently() call below
2316				out.Values[i] = graphql.Null
2317				continue
2318			}
2319
2320			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2321		case "tree":
2322			field := field
2323
2324			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2325				defer func() {
2326					if r := recover(); r != nil {
2327						ec.Error(ctx, ec.Recover(ctx, r))
2328					}
2329				}()
2330				res = ec._Repository_tree(ctx, field, obj)
2331				if res == graphql.Null {
2332					atomic.AddUint32(&fs.Invalids, 1)
2333				}
2334				return res
2335			}
2336
2337			if field.Deferrable != nil {
2338				dfs, ok := deferred[field.Deferrable.Label]
2339				di := 0
2340				if ok {
2341					dfs.AddField(field)
2342					di = len(dfs.Values) - 1
2343				} else {
2344					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2345					deferred[field.Deferrable.Label] = dfs
2346				}
2347				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2348					return innerFunc(ctx, dfs)
2349				})
2350
2351				// don't run the out.Concurrently() call below
2352				out.Values[i] = graphql.Null
2353				continue
2354			}
2355
2356			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2357		case "blob":
2358			field := field
2359
2360			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2361				defer func() {
2362					if r := recover(); r != nil {
2363						ec.Error(ctx, ec.Recover(ctx, r))
2364					}
2365				}()
2366				res = ec._Repository_blob(ctx, field, obj)
2367				return res
2368			}
2369
2370			if field.Deferrable != nil {
2371				dfs, ok := deferred[field.Deferrable.Label]
2372				di := 0
2373				if ok {
2374					dfs.AddField(field)
2375					di = len(dfs.Values) - 1
2376				} else {
2377					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2378					deferred[field.Deferrable.Label] = dfs
2379				}
2380				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2381					return innerFunc(ctx, dfs)
2382				})
2383
2384				// don't run the out.Concurrently() call below
2385				out.Values[i] = graphql.Null
2386				continue
2387			}
2388
2389			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2390		case "commits":
2391			field := field
2392
2393			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2394				defer func() {
2395					if r := recover(); r != nil {
2396						ec.Error(ctx, ec.Recover(ctx, r))
2397					}
2398				}()
2399				res = ec._Repository_commits(ctx, field, obj)
2400				if res == graphql.Null {
2401					atomic.AddUint32(&fs.Invalids, 1)
2402				}
2403				return res
2404			}
2405
2406			if field.Deferrable != nil {
2407				dfs, ok := deferred[field.Deferrable.Label]
2408				di := 0
2409				if ok {
2410					dfs.AddField(field)
2411					di = len(dfs.Values) - 1
2412				} else {
2413					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2414					deferred[field.Deferrable.Label] = dfs
2415				}
2416				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2417					return innerFunc(ctx, dfs)
2418				})
2419
2420				// don't run the out.Concurrently() call below
2421				out.Values[i] = graphql.Null
2422				continue
2423			}
2424
2425			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2426		case "commit":
2427			field := field
2428
2429			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
2430				defer func() {
2431					if r := recover(); r != nil {
2432						ec.Error(ctx, ec.Recover(ctx, r))
2433					}
2434				}()
2435				res = ec._Repository_commit(ctx, field, obj)
2436				return res
2437			}
2438
2439			if field.Deferrable != nil {
2440				dfs, ok := deferred[field.Deferrable.Label]
2441				di := 0
2442				if ok {
2443					dfs.AddField(field)
2444					di = len(dfs.Values) - 1
2445				} else {
2446					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2447					deferred[field.Deferrable.Label] = dfs
2448				}
2449				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2450					return innerFunc(ctx, dfs)
2451				})
2452
2453				// don't run the out.Concurrently() call below
2454				out.Values[i] = graphql.Null
2455				continue
2456			}
2457
2458			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2459		case "lastCommits":
2460			field := field
2461
2462			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2463				defer func() {
2464					if r := recover(); r != nil {
2465						ec.Error(ctx, ec.Recover(ctx, r))
2466					}
2467				}()
2468				res = ec._Repository_lastCommits(ctx, field, obj)
2469				if res == graphql.Null {
2470					atomic.AddUint32(&fs.Invalids, 1)
2471				}
2472				return res
2473			}
2474
2475			if field.Deferrable != nil {
2476				dfs, ok := deferred[field.Deferrable.Label]
2477				di := 0
2478				if ok {
2479					dfs.AddField(field)
2480					di = len(dfs.Values) - 1
2481				} else {
2482					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2483					deferred[field.Deferrable.Label] = dfs
2484				}
2485				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2486					return innerFunc(ctx, dfs)
2487				})
2488
2489				// don't run the out.Concurrently() call below
2490				out.Values[i] = graphql.Null
2491				continue
2492			}
2493
2494			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2495		case "validLabels":
2496			field := field
2497
2498			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
2499				defer func() {
2500					if r := recover(); r != nil {
2501						ec.Error(ctx, ec.Recover(ctx, r))
2502					}
2503				}()
2504				res = ec._Repository_validLabels(ctx, field, obj)
2505				if res == graphql.Null {
2506					atomic.AddUint32(&fs.Invalids, 1)
2507				}
2508				return res
2509			}
2510
2511			if field.Deferrable != nil {
2512				dfs, ok := deferred[field.Deferrable.Label]
2513				di := 0
2514				if ok {
2515					dfs.AddField(field)
2516					di = len(dfs.Values) - 1
2517				} else {
2518					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
2519					deferred[field.Deferrable.Label] = dfs
2520				}
2521				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
2522					return innerFunc(ctx, dfs)
2523				})
2524
2525				// don't run the out.Concurrently() call below
2526				out.Values[i] = graphql.Null
2527				continue
2528			}
2529
2530			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
2531		default:
2532			panic("unknown field " + strconv.Quote(field.Name))
2533		}
2534	}
2535	out.Dispatch(ctx)
2536	if out.Invalids > 0 {
2537		return graphql.Null
2538	}
2539
2540	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2541
2542	for label, dfs := range deferred {
2543		ec.processDeferredGroup(graphql.DeferredGroup{
2544			Label:    label,
2545			Path:     graphql.GetPath(ctx),
2546			FieldSet: dfs,
2547			Context:  ctx,
2548		})
2549	}
2550
2551	return out
2552}
2553
2554var repositoryConnectionImplementors = []string{"RepositoryConnection"}
2555
2556func (ec *executionContext) _RepositoryConnection(ctx context.Context, sel ast.SelectionSet, obj *models.RepositoryConnection) graphql.Marshaler {
2557	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryConnectionImplementors)
2558
2559	out := graphql.NewFieldSet(fields)
2560	deferred := make(map[string]*graphql.FieldSet)
2561	for i, field := range fields {
2562		switch field.Name {
2563		case "__typename":
2564			out.Values[i] = graphql.MarshalString("RepositoryConnection")
2565		case "edges":
2566			out.Values[i] = ec._RepositoryConnection_edges(ctx, field, obj)
2567			if out.Values[i] == graphql.Null {
2568				out.Invalids++
2569			}
2570		case "nodes":
2571			out.Values[i] = ec._RepositoryConnection_nodes(ctx, field, obj)
2572			if out.Values[i] == graphql.Null {
2573				out.Invalids++
2574			}
2575		case "pageInfo":
2576			out.Values[i] = ec._RepositoryConnection_pageInfo(ctx, field, obj)
2577			if out.Values[i] == graphql.Null {
2578				out.Invalids++
2579			}
2580		case "totalCount":
2581			out.Values[i] = ec._RepositoryConnection_totalCount(ctx, field, obj)
2582			if out.Values[i] == graphql.Null {
2583				out.Invalids++
2584			}
2585		default:
2586			panic("unknown field " + strconv.Quote(field.Name))
2587		}
2588	}
2589	out.Dispatch(ctx)
2590	if out.Invalids > 0 {
2591		return graphql.Null
2592	}
2593
2594	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2595
2596	for label, dfs := range deferred {
2597		ec.processDeferredGroup(graphql.DeferredGroup{
2598			Label:    label,
2599			Path:     graphql.GetPath(ctx),
2600			FieldSet: dfs,
2601			Context:  ctx,
2602		})
2603	}
2604
2605	return out
2606}
2607
2608var repositoryEdgeImplementors = []string{"RepositoryEdge"}
2609
2610func (ec *executionContext) _RepositoryEdge(ctx context.Context, sel ast.SelectionSet, obj *models.RepositoryEdge) graphql.Marshaler {
2611	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryEdgeImplementors)
2612
2613	out := graphql.NewFieldSet(fields)
2614	deferred := make(map[string]*graphql.FieldSet)
2615	for i, field := range fields {
2616		switch field.Name {
2617		case "__typename":
2618			out.Values[i] = graphql.MarshalString("RepositoryEdge")
2619		case "cursor":
2620			out.Values[i] = ec._RepositoryEdge_cursor(ctx, field, obj)
2621			if out.Values[i] == graphql.Null {
2622				out.Invalids++
2623			}
2624		case "node":
2625			out.Values[i] = ec._RepositoryEdge_node(ctx, field, obj)
2626			if out.Values[i] == graphql.Null {
2627				out.Invalids++
2628			}
2629		default:
2630			panic("unknown field " + strconv.Quote(field.Name))
2631		}
2632	}
2633	out.Dispatch(ctx)
2634	if out.Invalids > 0 {
2635		return graphql.Null
2636	}
2637
2638	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2639
2640	for label, dfs := range deferred {
2641		ec.processDeferredGroup(graphql.DeferredGroup{
2642			Label:    label,
2643			Path:     graphql.GetPath(ctx),
2644			FieldSet: dfs,
2645			Context:  ctx,
2646		})
2647	}
2648
2649	return out
2650}
2651
2652// endregion **************************** object.gotpl ****************************
2653
2654// region    ***************************** type.gotpl *****************************
2655
2656func (ec *executionContext) marshalNRepository2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Repository) graphql.Marshaler {
2657	ret := make(graphql.Array, len(v))
2658	var wg sync.WaitGroup
2659	isLen1 := len(v) == 1
2660	if !isLen1 {
2661		wg.Add(len(v))
2662	}
2663	for i := range v {
2664		i := i
2665		fc := &graphql.FieldContext{
2666			Index:  &i,
2667			Result: &v[i],
2668		}
2669		ctx := graphql.WithFieldContext(ctx, fc)
2670		f := func(i int) {
2671			defer func() {
2672				if r := recover(); r != nil {
2673					ec.Error(ctx, ec.Recover(ctx, r))
2674					ret = nil
2675				}
2676			}()
2677			if !isLen1 {
2678				defer wg.Done()
2679			}
2680			ret[i] = ec.marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, sel, v[i])
2681		}
2682		if isLen1 {
2683			f(i)
2684		} else {
2685			go f(i)
2686		}
2687
2688	}
2689	wg.Wait()
2690
2691	for _, e := range ret {
2692		if e == graphql.Null {
2693			return graphql.Null
2694		}
2695	}
2696
2697	return ret
2698}
2699
2700func (ec *executionContext) marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
2701	if v == nil {
2702		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2703			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2704		}
2705		return graphql.Null
2706	}
2707	return ec._Repository(ctx, sel, v)
2708}
2709
2710func (ec *executionContext) marshalNRepositoryConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryConnection(ctx context.Context, sel ast.SelectionSet, v models.RepositoryConnection) graphql.Marshaler {
2711	return ec._RepositoryConnection(ctx, sel, &v)
2712}
2713
2714func (ec *executionContext) marshalNRepositoryConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryConnection(ctx context.Context, sel ast.SelectionSet, v *models.RepositoryConnection) graphql.Marshaler {
2715	if v == nil {
2716		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2717			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2718		}
2719		return graphql.Null
2720	}
2721	return ec._RepositoryConnection(ctx, sel, v)
2722}
2723
2724func (ec *executionContext) marshalNRepositoryEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.RepositoryEdge) graphql.Marshaler {
2725	ret := make(graphql.Array, len(v))
2726	var wg sync.WaitGroup
2727	isLen1 := len(v) == 1
2728	if !isLen1 {
2729		wg.Add(len(v))
2730	}
2731	for i := range v {
2732		i := i
2733		fc := &graphql.FieldContext{
2734			Index:  &i,
2735			Result: &v[i],
2736		}
2737		ctx := graphql.WithFieldContext(ctx, fc)
2738		f := func(i int) {
2739			defer func() {
2740				if r := recover(); r != nil {
2741					ec.Error(ctx, ec.Recover(ctx, r))
2742					ret = nil
2743				}
2744			}()
2745			if !isLen1 {
2746				defer wg.Done()
2747			}
2748			ret[i] = ec.marshalNRepositoryEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdge(ctx, sel, v[i])
2749		}
2750		if isLen1 {
2751			f(i)
2752		} else {
2753			go f(i)
2754		}
2755
2756	}
2757	wg.Wait()
2758
2759	for _, e := range ret {
2760		if e == graphql.Null {
2761			return graphql.Null
2762		}
2763	}
2764
2765	return ret
2766}
2767
2768func (ec *executionContext) marshalNRepositoryEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdge(ctx context.Context, sel ast.SelectionSet, v *models.RepositoryEdge) graphql.Marshaler {
2769	if v == nil {
2770		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2771			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2772		}
2773		return graphql.Null
2774	}
2775	return ec._RepositoryEdge(ctx, sel, v)
2776}
2777
2778func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
2779	if v == nil {
2780		return graphql.Null
2781	}
2782	return ec._Repository(ctx, sel, v)
2783}
2784
2785// endregion ***************************** type.gotpl *****************************