generated.go

// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package graphql

import (
	"bytes"
	"context"
	"embed"
	"errors"
	"fmt"
	"math"
	"strconv"
	"sync/atomic"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)

// region    ************************** generated!.gotpl **************************

// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{SchemaData: cfg.Schema, Resolvers: cfg.Resolvers, Directives: cfg.Directives, ComplexityRoot: cfg.Complexity}
}

type Config = graphql.Config[ResolverRoot, DirectiveRoot, ComplexityRoot]

type ResolverRoot interface {
	Mutation() MutationResolver
	Query() QueryResolver
}

type DirectiveRoot struct {
	HasRole  func(ctx context.Context, obj any, next graphql.Resolver, role Role) (res any, err error)
	LoggedIn func(ctx context.Context, obj any, next graphql.Resolver) (res any, err error)
}

type ComplexityRoot struct {
	Book struct {
		ID    func(childComplexity int) int
		Title func(childComplexity int) int
		URI   func(childComplexity int) int
	}

	Comment struct {
		Content  func(childComplexity int) int
		Created  func(childComplexity int) int
		ID       func(childComplexity int) int
		Modified func(childComplexity int) int
		Post     func(childComplexity int) int
		URI      func(childComplexity int) int
		User     func(childComplexity int) int
	}

	Geo struct {
		Lat  func(childComplexity int) int
		Long func(childComplexity int) int
	}

	Link struct {
		Created     func(childComplexity int) int
		Description func(childComplexity int) int
		ID          func(childComplexity int) int
		Modified    func(childComplexity int) int
		Screenshot  func(childComplexity int) int
		Tags        func(childComplexity int) int
		Title       func(childComplexity int) int
		URI         func(childComplexity int) int
	}

	Log struct {
		Created     func(childComplexity int) int
		Description func(childComplexity int) int
		Duration    func(childComplexity int) int
		ID          func(childComplexity int) int
		Modified    func(childComplexity int) int
		Project     func(childComplexity int) int
		Sector      func(childComplexity int) int
		Started     func(childComplexity int) int
		Stopped     func(childComplexity int) int
		URI         func(childComplexity int) int
		User        func(childComplexity int) int
	}

	Mutation struct {
		AddComment  func(childComplexity int, input AddComment) int
		CreatePost  func(childComplexity int, input EditPost) int
		EditPost    func(childComplexity int, input EditPost) int
		InsertLog   func(childComplexity int, input NewLog) int
		UpsertBook  func(childComplexity int, input EditBook) int
		UpsertLink  func(childComplexity int, input NewLink) int
		UpsertStat  func(childComplexity int, input NewStat) int
		UpsertTweet func(childComplexity int, input NewTweet) int
	}

	Photo struct {
		ContentType func(childComplexity int) int
		Created     func(childComplexity int) int
		ID          func(childComplexity int) int
		Modified    func(childComplexity int) int
		URI         func(childComplexity int) int
		Year        func(childComplexity int) int
	}

	Post struct {
		Comments    func(childComplexity int, input *Limit) int
		Content     func(childComplexity int) int
		Created     func(childComplexity int) int
		Datetime    func(childComplexity int) int
		Draft       func(childComplexity int) int
		ID          func(childComplexity int) int
		Links       func(childComplexity int) int
		Modified    func(childComplexity int) int
		Next        func(childComplexity int) int
		Prev        func(childComplexity int) int
		Readtime    func(childComplexity int) int
		Related     func(childComplexity int, input *Limit) int
		SocialImage func(childComplexity int) int
		Summary     func(childComplexity int) int
		Tags        func(childComplexity int) int
		Title       func(childComplexity int) int
		URI         func(childComplexity int) int
	}

	Query struct {
		Books              func(childComplexity int, input *Limit) int
		Comments           func(childComplexity int, input *Limit) int
		Counts             func(childComplexity int) int
		Drafts             func(childComplexity int, input *Limit) int
		FuturePosts        func(childComplexity int, input *Limit) int
		HomeTimelineURLs   func(childComplexity int, input *Limit) int
		Link               func(childComplexity int, id *string, url *URI) int
		Links              func(childComplexity int, input *Limit) int
		Log                func(childComplexity int, id string) int
		Logs               func(childComplexity int, input *Limit) int
		NextPost           func(childComplexity int, id string) int
		Photos             func(childComplexity int, input *Limit) int
		Post               func(childComplexity int, id string) int
		Posts              func(childComplexity int, input *Limit) int
		PostsByTag         func(childComplexity int, id string) int
		PrevPost           func(childComplexity int, id string) int
		Search             func(childComplexity int, query string, input *Limit) int
		Stat               func(childComplexity int, key string, input *Limit) int
		Stats              func(childComplexity int, count *int) int
		Tags               func(childComplexity int) int
		Time               func(childComplexity int) int
		Tweet              func(childComplexity int, id string) int
		Tweets             func(childComplexity int, input *Limit) int
		TweetsByScreenName func(childComplexity int, screenName string, input *Limit) int
		Whoami             func(childComplexity int) int
	}

	Stat struct {
		Key   func(childComplexity int) int
		Value func(childComplexity int) int
		When  func(childComplexity int) int
	}

	Tweet struct {
		FavoriteCount func(childComplexity int) int
		Hashtags      func(childComplexity int) int
		ID            func(childComplexity int) int
		Posted        func(childComplexity int) int
		RetweetCount  func(childComplexity int) int
		ScreenName    func(childComplexity int) int
		Symbols       func(childComplexity int) int
		Text          func(childComplexity int) int
		URI           func(childComplexity int) int
		Urls          func(childComplexity int) int
		UserMentions  func(childComplexity int) int
	}

	TwitterURL struct {
		CreatedAt  func(childComplexity int) int
		Link       func(childComplexity int) int
		ModifiedAt func(childComplexity int) int
		TweetIDs   func(childComplexity int) int
		Tweets     func(childComplexity int) int
		URI        func(childComplexity int) int
	}

	User struct {
		APIKey   func(childComplexity int) int
		Created  func(childComplexity int) int
		ID       func(childComplexity int) int
		Modified func(childComplexity int) int
		Name     func(childComplexity int) int
		Role     func(childComplexity int) int
	}
}

type MutationResolver interface {
	UpsertBook(ctx context.Context, input EditBook) (*Book, error)
	UpsertLink(ctx context.Context, input NewLink) (*Link, error)
	UpsertStat(ctx context.Context, input NewStat) (*Stat, error)
	UpsertTweet(ctx context.Context, input NewTweet) (*Tweet, error)
	AddComment(ctx context.Context, input AddComment) (*Comment, error)
	CreatePost(ctx context.Context, input EditPost) (*Post, error)
	EditPost(ctx context.Context, input EditPost) (*Post, error)
	InsertLog(ctx context.Context, input NewLog) (*Log, error)
}
type QueryResolver interface {
	Books(ctx context.Context, input *Limit) ([]*Book, error)
	Links(ctx context.Context, input *Limit) ([]*Link, error)
	Link(ctx context.Context, id *string, url *URI) (*Link, error)
	Stats(ctx context.Context, count *int) ([]*Stat, error)
	Stat(ctx context.Context, key string, input *Limit) ([]*Stat, error)
	Counts(ctx context.Context) ([]*Stat, error)
	Whoami(ctx context.Context) (*User, error)
	Tweets(ctx context.Context, input *Limit) ([]*Tweet, error)
	Tweet(ctx context.Context, id string) (*Tweet, error)
	TweetsByScreenName(ctx context.Context, screenName string, input *Limit) ([]*Tweet, error)
	HomeTimelineURLs(ctx context.Context, input *Limit) ([]*TwitterURL, error)
	Time(ctx context.Context) (*time.Time, error)
	Drafts(ctx context.Context, input *Limit) ([]*Post, error)
	FuturePosts(ctx context.Context, input *Limit) ([]*Post, error)
	Posts(ctx context.Context, input *Limit) ([]*Post, error)
	Comments(ctx context.Context, input *Limit) ([]*Comment, error)
	Search(ctx context.Context, query string, input *Limit) ([]*Post, error)
	Post(ctx context.Context, id string) (*Post, error)
	NextPost(ctx context.Context, id string) (*Post, error)
	PrevPost(ctx context.Context, id string) (*Post, error)
	PostsByTag(ctx context.Context, id string) ([]*Post, error)
	Tags(ctx context.Context) ([]string, error)
	Logs(ctx context.Context, input *Limit) ([]*Log, error)
	Log(ctx context.Context, id string) (*Log, error)
	Photos(ctx context.Context, input *Limit) ([]*Photo, error)
}

type executableSchema graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot]

func (e *executableSchema) Schema() *ast.Schema {
	if e.SchemaData != nil {
		return e.SchemaData
	}
	return parsedSchema
}

func (e *executableSchema) Complexity(ctx context.Context, typeName, field string, childComplexity int, rawArgs map[string]any) (int, bool) {
	ec := newExecutionContext(nil, e, nil)
	_ = ec
	switch typeName + "." + field {

	case "Book.id":
		if e.ComplexityRoot.Book.ID == nil {
			break
		}

		return e.ComplexityRoot.Book.ID(childComplexity), true
	case "Book.title":
		if e.ComplexityRoot.Book.Title == nil {
			break
		}

		return e.ComplexityRoot.Book.Title(childComplexity), true
	case "Book.uri":
		if e.ComplexityRoot.Book.URI == nil {
			break
		}

		return e.ComplexityRoot.Book.URI(childComplexity), true

	case "Comment.content":
		if e.ComplexityRoot.Comment.Content == nil {
			break
		}

		return e.ComplexityRoot.Comment.Content(childComplexity), true
	case "Comment.created":
		if e.ComplexityRoot.Comment.Created == nil {
			break
		}

		return e.ComplexityRoot.Comment.Created(childComplexity), true
	case "Comment.id":
		if e.ComplexityRoot.Comment.ID == nil {
			break
		}

		return e.ComplexityRoot.Comment.ID(childComplexity), true
	case "Comment.modified":
		if e.ComplexityRoot.Comment.Modified == nil {
			break
		}

		return e.ComplexityRoot.Comment.Modified(childComplexity), true
	case "Comment.post":
		if e.ComplexityRoot.Comment.Post == nil {
			break
		}

		return e.ComplexityRoot.Comment.Post(childComplexity), true
	case "Comment.uri":
		if e.ComplexityRoot.Comment.URI == nil {
			break
		}

		return e.ComplexityRoot.Comment.URI(childComplexity), true
	case "Comment.user":
		if e.ComplexityRoot.Comment.User == nil {
			break
		}

		return e.ComplexityRoot.Comment.User(childComplexity), true

	case "Geo.lat":
		if e.ComplexityRoot.Geo.Lat == nil {
			break
		}

		return e.ComplexityRoot.Geo.Lat(childComplexity), true
	case "Geo.long":
		if e.ComplexityRoot.Geo.Long == nil {
			break
		}

		return e.ComplexityRoot.Geo.Long(childComplexity), true

	case "Link.created":
		if e.ComplexityRoot.Link.Created == nil {
			break
		}

		return e.ComplexityRoot.Link.Created(childComplexity), true
	case "Link.description":
		if e.ComplexityRoot.Link.Description == nil {
			break
		}

		return e.ComplexityRoot.Link.Description(childComplexity), true
	case "Link.id":
		if e.ComplexityRoot.Link.ID == nil {
			break
		}

		return e.ComplexityRoot.Link.ID(childComplexity), true
	case "Link.modified":
		if e.ComplexityRoot.Link.Modified == nil {
			break
		}

		return e.ComplexityRoot.Link.Modified(childComplexity), true
	case "Link.screenshot":
		if e.ComplexityRoot.Link.Screenshot == nil {
			break
		}

		return e.ComplexityRoot.Link.Screenshot(childComplexity), true
	case "Link.tags":
		if e.ComplexityRoot.Link.Tags == nil {
			break
		}

		return e.ComplexityRoot.Link.Tags(childComplexity), true
	case "Link.title":
		if e.ComplexityRoot.Link.Title == nil {
			break
		}

		return e.ComplexityRoot.Link.Title(childComplexity), true
	case "Link.uri":
		if e.ComplexityRoot.Link.URI == nil {
			break
		}

		return e.ComplexityRoot.Link.URI(childComplexity), true

	case "Log.created":
		if e.ComplexityRoot.Log.Created == nil {
			break
		}

		return e.ComplexityRoot.Log.Created(childComplexity), true
	case "Log.description":
		if e.ComplexityRoot.Log.Description == nil {
			break
		}

		return e.ComplexityRoot.Log.Description(childComplexity), true
	case "Log.duration":
		if e.ComplexityRoot.Log.Duration == nil {
			break
		}

		return e.ComplexityRoot.Log.Duration(childComplexity), true
	case "Log.id":
		if e.ComplexityRoot.Log.ID == nil {
			break
		}

		return e.ComplexityRoot.Log.ID(childComplexity), true
	case "Log.modified":
		if e.ComplexityRoot.Log.Modified == nil {
			break
		}

		return e.ComplexityRoot.Log.Modified(childComplexity), true
	case "Log.project":
		if e.ComplexityRoot.Log.Project == nil {
			break
		}

		return e.ComplexityRoot.Log.Project(childComplexity), true
	case "Log.sector":
		if e.ComplexityRoot.Log.Sector == nil {
			break
		}

		return e.ComplexityRoot.Log.Sector(childComplexity), true
	case "Log.started":
		if e.ComplexityRoot.Log.Started == nil {
			break
		}

		return e.ComplexityRoot.Log.Started(childComplexity), true
	case "Log.stopped":
		if e.ComplexityRoot.Log.Stopped == nil {
			break
		}

		return e.ComplexityRoot.Log.Stopped(childComplexity), true
	case "Log.uri":
		if e.ComplexityRoot.Log.URI == nil {
			break
		}

		return e.ComplexityRoot.Log.URI(childComplexity), true
	case "Log.user":
		if e.ComplexityRoot.Log.User == nil {
			break
		}

		return e.ComplexityRoot.Log.User(childComplexity), true

	case "Mutation.addComment":
		if e.ComplexityRoot.Mutation.AddComment == nil {
			break
		}

		args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.AddComment(childComplexity, args["input"].(AddComment)), true
	case "Mutation.createPost":
		if e.ComplexityRoot.Mutation.CreatePost == nil {
			break
		}

		args, err := ec.field_Mutation_createPost_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.CreatePost(childComplexity, args["input"].(EditPost)), true
	case "Mutation.editPost":
		if e.ComplexityRoot.Mutation.EditPost == nil {
			break
		}

		args, err := ec.field_Mutation_editPost_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.EditPost(childComplexity, args["input"].(EditPost)), true
	case "Mutation.insertLog":
		if e.ComplexityRoot.Mutation.InsertLog == nil {
			break
		}

		args, err := ec.field_Mutation_insertLog_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.InsertLog(childComplexity, args["input"].(NewLog)), true
	case "Mutation.upsertBook":
		if e.ComplexityRoot.Mutation.UpsertBook == nil {
			break
		}

		args, err := ec.field_Mutation_upsertBook_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.UpsertBook(childComplexity, args["input"].(EditBook)), true
	case "Mutation.upsertLink":
		if e.ComplexityRoot.Mutation.UpsertLink == nil {
			break
		}

		args, err := ec.field_Mutation_upsertLink_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.UpsertLink(childComplexity, args["input"].(NewLink)), true
	case "Mutation.upsertStat":
		if e.ComplexityRoot.Mutation.UpsertStat == nil {
			break
		}

		args, err := ec.field_Mutation_upsertStat_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.UpsertStat(childComplexity, args["input"].(NewStat)), true
	case "Mutation.upsertTweet":
		if e.ComplexityRoot.Mutation.UpsertTweet == nil {
			break
		}

		args, err := ec.field_Mutation_upsertTweet_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Mutation.UpsertTweet(childComplexity, args["input"].(NewTweet)), true

	case "Photo.content_type":
		if e.ComplexityRoot.Photo.ContentType == nil {
			break
		}

		return e.ComplexityRoot.Photo.ContentType(childComplexity), true
	case "Photo.created":
		if e.ComplexityRoot.Photo.Created == nil {
			break
		}

		return e.ComplexityRoot.Photo.Created(childComplexity), true
	case "Photo.id":
		if e.ComplexityRoot.Photo.ID == nil {
			break
		}

		return e.ComplexityRoot.Photo.ID(childComplexity), true
	case "Photo.modified":
		if e.ComplexityRoot.Photo.Modified == nil {
			break
		}

		return e.ComplexityRoot.Photo.Modified(childComplexity), true
	case "Photo.uri":
		if e.ComplexityRoot.Photo.URI == nil {
			break
		}

		return e.ComplexityRoot.Photo.URI(childComplexity), true
	case "Photo.year":
		if e.ComplexityRoot.Photo.Year == nil {
			break
		}

		return e.ComplexityRoot.Photo.Year(childComplexity), true

	case "Post.comments":
		if e.ComplexityRoot.Post.Comments == nil {
			break
		}

		args, err := ec.field_Post_comments_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Post.Comments(childComplexity, args["input"].(*Limit)), true
	case "Post.content":
		if e.ComplexityRoot.Post.Content == nil {
			break
		}

		return e.ComplexityRoot.Post.Content(childComplexity), true
	case "Post.created":
		if e.ComplexityRoot.Post.Created == nil {
			break
		}

		return e.ComplexityRoot.Post.Created(childComplexity), true
	case "Post.datetime":
		if e.ComplexityRoot.Post.Datetime == nil {
			break
		}

		return e.ComplexityRoot.Post.Datetime(childComplexity), true
	case "Post.draft":
		if e.ComplexityRoot.Post.Draft == nil {
			break
		}

		return e.ComplexityRoot.Post.Draft(childComplexity), true
	case "Post.id":
		if e.ComplexityRoot.Post.ID == nil {
			break
		}

		return e.ComplexityRoot.Post.ID(childComplexity), true
	case "Post.links":
		if e.ComplexityRoot.Post.Links == nil {
			break
		}

		return e.ComplexityRoot.Post.Links(childComplexity), true
	case "Post.modified":
		if e.ComplexityRoot.Post.Modified == nil {
			break
		}

		return e.ComplexityRoot.Post.Modified(childComplexity), true
	case "Post.next":
		if e.ComplexityRoot.Post.Next == nil {
			break
		}

		return e.ComplexityRoot.Post.Next(childComplexity), true
	case "Post.prev":
		if e.ComplexityRoot.Post.Prev == nil {
			break
		}

		return e.ComplexityRoot.Post.Prev(childComplexity), true
	case "Post.readtime":
		if e.ComplexityRoot.Post.Readtime == nil {
			break
		}

		return e.ComplexityRoot.Post.Readtime(childComplexity), true
	case "Post.related":
		if e.ComplexityRoot.Post.Related == nil {
			break
		}

		args, err := ec.field_Post_related_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Post.Related(childComplexity, args["input"].(*Limit)), true
	case "Post.social_image":
		if e.ComplexityRoot.Post.SocialImage == nil {
			break
		}

		return e.ComplexityRoot.Post.SocialImage(childComplexity), true
	case "Post.summary":
		if e.ComplexityRoot.Post.Summary == nil {
			break
		}

		return e.ComplexityRoot.Post.Summary(childComplexity), true
	case "Post.tags":
		if e.ComplexityRoot.Post.Tags == nil {
			break
		}

		return e.ComplexityRoot.Post.Tags(childComplexity), true
	case "Post.title":
		if e.ComplexityRoot.Post.Title == nil {
			break
		}

		return e.ComplexityRoot.Post.Title(childComplexity), true
	case "Post.uri":
		if e.ComplexityRoot.Post.URI == nil {
			break
		}

		return e.ComplexityRoot.Post.URI(childComplexity), true

	case "Query.books":
		if e.ComplexityRoot.Query.Books == nil {
			break
		}

		args, err := ec.field_Query_books_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Books(childComplexity, args["input"].(*Limit)), true
	case "Query.comments":
		if e.ComplexityRoot.Query.Comments == nil {
			break
		}

		args, err := ec.field_Query_comments_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Comments(childComplexity, args["input"].(*Limit)), true
	case "Query.counts":
		if e.ComplexityRoot.Query.Counts == nil {
			break
		}

		return e.ComplexityRoot.Query.Counts(childComplexity), true
	case "Query.drafts":
		if e.ComplexityRoot.Query.Drafts == nil {
			break
		}

		args, err := ec.field_Query_drafts_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Drafts(childComplexity, args["input"].(*Limit)), true
	case "Query.futurePosts":
		if e.ComplexityRoot.Query.FuturePosts == nil {
			break
		}

		args, err := ec.field_Query_futurePosts_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.FuturePosts(childComplexity, args["input"].(*Limit)), true
	case "Query.homeTimelineURLs":
		if e.ComplexityRoot.Query.HomeTimelineURLs == nil {
			break
		}

		args, err := ec.field_Query_homeTimelineURLs_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.HomeTimelineURLs(childComplexity, args["input"].(*Limit)), true

	case "Query.link":
		if e.ComplexityRoot.Query.Link == nil {
			break
		}

		args, err := ec.field_Query_link_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Link(childComplexity, args["id"].(*string), args["url"].(*URI)), true
	case "Query.links":
		if e.ComplexityRoot.Query.Links == nil {
			break
		}

		args, err := ec.field_Query_links_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Links(childComplexity, args["input"].(*Limit)), true
	case "Query.log":
		if e.ComplexityRoot.Query.Log == nil {
			break
		}

		args, err := ec.field_Query_log_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Log(childComplexity, args["id"].(string)), true
	case "Query.logs":
		if e.ComplexityRoot.Query.Logs == nil {
			break
		}

		args, err := ec.field_Query_logs_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Logs(childComplexity, args["input"].(*Limit)), true
	case "Query.nextPost":
		if e.ComplexityRoot.Query.NextPost == nil {
			break
		}

		args, err := ec.field_Query_nextPost_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.NextPost(childComplexity, args["id"].(string)), true
	case "Query.photos":
		if e.ComplexityRoot.Query.Photos == nil {
			break
		}

		args, err := ec.field_Query_photos_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Photos(childComplexity, args["input"].(*Limit)), true
	case "Query.post":
		if e.ComplexityRoot.Query.Post == nil {
			break
		}

		args, err := ec.field_Query_post_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Post(childComplexity, args["id"].(string)), true
	case "Query.posts":
		if e.ComplexityRoot.Query.Posts == nil {
			break
		}

		args, err := ec.field_Query_posts_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Posts(childComplexity, args["input"].(*Limit)), true
	case "Query.postsByTag":
		if e.ComplexityRoot.Query.PostsByTag == nil {
			break
		}

		args, err := ec.field_Query_postsByTag_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.PostsByTag(childComplexity, args["id"].(string)), true
	case "Query.prevPost":
		if e.ComplexityRoot.Query.PrevPost == nil {
			break
		}

		args, err := ec.field_Query_prevPost_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.PrevPost(childComplexity, args["id"].(string)), true
	case "Query.search":
		if e.ComplexityRoot.Query.Search == nil {
			break
		}

		args, err := ec.field_Query_search_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Search(childComplexity, args["query"].(string), args["input"].(*Limit)), true
	case "Query.stat":
		if e.ComplexityRoot.Query.Stat == nil {
			break
		}

		args, err := ec.field_Query_stat_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Stat(childComplexity, args["key"].(string), args["input"].(*Limit)), true
	case "Query.stats":
		if e.ComplexityRoot.Query.Stats == nil {
			break
		}

		args, err := ec.field_Query_stats_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Stats(childComplexity, args["count"].(*int)), true
	case "Query.tags":
		if e.ComplexityRoot.Query.Tags == nil {
			break
		}

		return e.ComplexityRoot.Query.Tags(childComplexity), true
	case "Query.time":
		if e.ComplexityRoot.Query.Time == nil {
			break
		}

		return e.ComplexityRoot.Query.Time(childComplexity), true
	case "Query.tweet":
		if e.ComplexityRoot.Query.Tweet == nil {
			break
		}

		args, err := ec.field_Query_tweet_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Tweet(childComplexity, args["id"].(string)), true
	case "Query.tweets":
		if e.ComplexityRoot.Query.Tweets == nil {
			break
		}

		args, err := ec.field_Query_tweets_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.Tweets(childComplexity, args["input"].(*Limit)), true
	case "Query.tweetsByScreenName":
		if e.ComplexityRoot.Query.TweetsByScreenName == nil {
			break
		}

		args, err := ec.field_Query_tweetsByScreenName_args(ctx, rawArgs)
		if err != nil {
			return 0, false
		}

		return e.ComplexityRoot.Query.TweetsByScreenName(childComplexity, args["screen_name"].(string), args["input"].(*Limit)), true
	case "Query.whoami":
		if e.ComplexityRoot.Query.Whoami == nil {
			break
		}

		return e.ComplexityRoot.Query.Whoami(childComplexity), true

	case "Stat.key":
		if e.ComplexityRoot.Stat.Key == nil {
			break
		}

		return e.ComplexityRoot.Stat.Key(childComplexity), true
	case "Stat.value":
		if e.ComplexityRoot.Stat.Value == nil {
			break
		}

		return e.ComplexityRoot.Stat.Value(childComplexity), true
	case "Stat.when":
		if e.ComplexityRoot.Stat.When == nil {
			break
		}

		return e.ComplexityRoot.Stat.When(childComplexity), true

	case "Tweet.favorite_count":
		if e.ComplexityRoot.Tweet.FavoriteCount == nil {
			break
		}

		return e.ComplexityRoot.Tweet.FavoriteCount(childComplexity), true
	case "Tweet.hashtags":
		if e.ComplexityRoot.Tweet.Hashtags == nil {
			break
		}

		return e.ComplexityRoot.Tweet.Hashtags(childComplexity), true
	case "Tweet.id":
		if e.ComplexityRoot.Tweet.ID == nil {
			break
		}

		return e.ComplexityRoot.Tweet.ID(childComplexity), true
	case "Tweet.posted":
		if e.ComplexityRoot.Tweet.Posted == nil {
			break
		}

		return e.ComplexityRoot.Tweet.Posted(childComplexity), true
	case "Tweet.retweet_count":
		if e.ComplexityRoot.Tweet.RetweetCount == nil {
			break
		}

		return e.ComplexityRoot.Tweet.RetweetCount(childComplexity), true
	case "Tweet.screen_name":
		if e.ComplexityRoot.Tweet.ScreenName == nil {
			break
		}

		return e.ComplexityRoot.Tweet.ScreenName(childComplexity), true
	case "Tweet.symbols":
		if e.ComplexityRoot.Tweet.Symbols == nil {
			break
		}

		return e.ComplexityRoot.Tweet.Symbols(childComplexity), true
	case "Tweet.text":
		if e.ComplexityRoot.Tweet.Text == nil {
			break
		}

		return e.ComplexityRoot.Tweet.Text(childComplexity), true
	case "Tweet.uri":
		if e.ComplexityRoot.Tweet.URI == nil {
			break
		}

		return e.ComplexityRoot.Tweet.URI(childComplexity), true
	case "Tweet.urls":
		if e.ComplexityRoot.Tweet.Urls == nil {
			break
		}

		return e.ComplexityRoot.Tweet.Urls(childComplexity), true
	case "Tweet.user_mentions":
		if e.ComplexityRoot.Tweet.UserMentions == nil {
			break
		}

		return e.ComplexityRoot.Tweet.UserMentions(childComplexity), true

	case "TwitterURL.createdAt":
		if e.ComplexityRoot.TwitterURL.CreatedAt == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.CreatedAt(childComplexity), true
	case "TwitterURL.link":
		if e.ComplexityRoot.TwitterURL.Link == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.Link(childComplexity), true
	case "TwitterURL.modifiedAt":
		if e.ComplexityRoot.TwitterURL.ModifiedAt == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.ModifiedAt(childComplexity), true
	case "TwitterURL.tweetIDs":
		if e.ComplexityRoot.TwitterURL.TweetIDs == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.TweetIDs(childComplexity), true
	case "TwitterURL.tweets":
		if e.ComplexityRoot.TwitterURL.Tweets == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.Tweets(childComplexity), true
	case "TwitterURL.uri":
		if e.ComplexityRoot.TwitterURL.URI == nil {
			break
		}

		return e.ComplexityRoot.TwitterURL.URI(childComplexity), true

	case "User.apikey":
		if e.ComplexityRoot.User.APIKey == nil {
			break
		}

		return e.ComplexityRoot.User.APIKey(childComplexity), true
	case "User.created":
		if e.ComplexityRoot.User.Created == nil {
			break
		}

		return e.ComplexityRoot.User.Created(childComplexity), true
	case "User.id":
		if e.ComplexityRoot.User.ID == nil {
			break
		}

		return e.ComplexityRoot.User.ID(childComplexity), true
	case "User.modified":
		if e.ComplexityRoot.User.Modified == nil {
			break
		}

		return e.ComplexityRoot.User.Modified(childComplexity), true
	case "User.name":
		if e.ComplexityRoot.User.Name == nil {
			break
		}

		return e.ComplexityRoot.User.Name(childComplexity), true
	case "User.role":
		if e.ComplexityRoot.User.Role == nil {
			break
		}

		return e.ComplexityRoot.User.Role(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	opCtx := graphql.GetOperationContext(ctx)
	ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult))
	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
		ec.unmarshalInputAddComment,
		ec.unmarshalInputEditBook,
		ec.unmarshalInputEditPost,
		ec.unmarshalInputInputGeo,
		ec.unmarshalInputLimit,
		ec.unmarshalInputNewLink,
		ec.unmarshalInputNewLog,
		ec.unmarshalInputNewStat,
		ec.unmarshalInputNewTweet,
	)
	first := true

	switch opCtx.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			var response graphql.Response
			var data graphql.Marshaler
			if first {
				first = false
				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
				data = ec._Query(ctx, opCtx.Operation.SelectionSet)
			} else {
				if atomic.LoadInt32(&ec.PendingDeferred) > 0 {
					result := <-ec.DeferredResults
					atomic.AddInt32(&ec.PendingDeferred, -1)
					data = result.Result
					response.Path = result.Path
					response.Label = result.Label
					response.Errors = result.Errors
				} else {
					return nil
				}
			}
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			response.Data = buf.Bytes()
			if atomic.LoadInt32(&ec.Deferred) > 0 {
				hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0
				response.HasNext = &hasNext
			}

			return &response
		}
	case ast.Mutation:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
			data := ec._Mutation(ctx, opCtx.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}

	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}

type executionContext struct {
	*graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]
}

func newExecutionContext(
	opCtx *graphql.OperationContext,
	execSchema *executableSchema,
	deferredResults chan graphql.DeferredResult,
) *executionContext {
	return &executionContext{
		ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot](
			opCtx,
			(*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema),
			parsedSchema,
			deferredResults,
		),
	}
}

//go:embed "blog.graphql" "generics.graphql" "wiki.graphql"
var sourcesFS embed.FS

func sourceData(filename string) string {
	data, err := sourcesFS.ReadFile(filename)
	if err != nil {
		panic(fmt.Sprintf("codegen problem: %s not available", filename))
	}
	return string(data)
}

var sources = []*ast.Source{
	{Name: "blog.graphql", Input: sourceData("blog.graphql"), BuiltIn: false},
	{Name: "generics.graphql", Input: sourceData("generics.graphql"), BuiltIn: false},
	{Name: "wiki.graphql", Input: sourceData("wiki.graphql"), BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

// childFields_* functions provide shared child field context lookups.
// Each function is generated once per unique object type, deduplicating the
// switch statements that were previously inlined in every fieldContext_* function.

func (ec *executionContext) childFields_Book(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Book_id(ctx, field)
	case "uri":
		return ec.fieldContext_Book_uri(ctx, field)
	case "title":
		return ec.fieldContext_Book_title(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Book", field.Name)
}

func (ec *executionContext) childFields_Comment(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Comment_id(ctx, field)
	case "post":
		return ec.fieldContext_Comment_post(ctx, field)
	case "user":
		return ec.fieldContext_Comment_user(ctx, field)
	case "content":
		return ec.fieldContext_Comment_content(ctx, field)
	case "created":
		return ec.fieldContext_Comment_created(ctx, field)
	case "modified":
		return ec.fieldContext_Comment_modified(ctx, field)
	case "uri":
		return ec.fieldContext_Comment_uri(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Comment", field.Name)
}

func (ec *executionContext) childFields_Link(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Link_id(ctx, field)
	case "title":
		return ec.fieldContext_Link_title(ctx, field)
	case "uri":
		return ec.fieldContext_Link_uri(ctx, field)
	case "created":
		return ec.fieldContext_Link_created(ctx, field)
	case "description":
		return ec.fieldContext_Link_description(ctx, field)
	case "screenshot":
		return ec.fieldContext_Link_screenshot(ctx, field)
	case "tags":
		return ec.fieldContext_Link_tags(ctx, field)
	case "modified":
		return ec.fieldContext_Link_modified(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Link", field.Name)
}

func (ec *executionContext) childFields_Log(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Log_id(ctx, field)
	case "description":
		return ec.fieldContext_Log_description(ctx, field)
	case "project":
		return ec.fieldContext_Log_project(ctx, field)
	case "user":
		return ec.fieldContext_Log_user(ctx, field)
	case "duration":
		return ec.fieldContext_Log_duration(ctx, field)
	case "uri":
		return ec.fieldContext_Log_uri(ctx, field)
	case "sector":
		return ec.fieldContext_Log_sector(ctx, field)
	case "started":
		return ec.fieldContext_Log_started(ctx, field)
	case "stopped":
		return ec.fieldContext_Log_stopped(ctx, field)
	case "created":
		return ec.fieldContext_Log_created(ctx, field)
	case "modified":
		return ec.fieldContext_Log_modified(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Log", field.Name)
}

func (ec *executionContext) childFields_Photo(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Photo_id(ctx, field)
	case "year":
		return ec.fieldContext_Photo_year(ctx, field)
	case "content_type":
		return ec.fieldContext_Photo_content_type(ctx, field)
	case "created":
		return ec.fieldContext_Photo_created(ctx, field)
	case "modified":
		return ec.fieldContext_Photo_modified(ctx, field)
	case "uri":
		return ec.fieldContext_Photo_uri(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Photo", field.Name)
}

func (ec *executionContext) childFields_Post(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Post_id(ctx, field)
	case "title":
		return ec.fieldContext_Post_title(ctx, field)
	case "content":
		return ec.fieldContext_Post_content(ctx, field)
	case "summary":
		return ec.fieldContext_Post_summary(ctx, field)
	case "readtime":
		return ec.fieldContext_Post_readtime(ctx, field)
	case "social_image":
		return ec.fieldContext_Post_social_image(ctx, field)
	case "datetime":
		return ec.fieldContext_Post_datetime(ctx, field)
	case "created":
		return ec.fieldContext_Post_created(ctx, field)
	case "modified":
		return ec.fieldContext_Post_modified(ctx, field)
	case "draft":
		return ec.fieldContext_Post_draft(ctx, field)
	case "tags":
		return ec.fieldContext_Post_tags(ctx, field)
	case "links":
		return ec.fieldContext_Post_links(ctx, field)
	case "uri":
		return ec.fieldContext_Post_uri(ctx, field)
	case "next":
		return ec.fieldContext_Post_next(ctx, field)
	case "prev":
		return ec.fieldContext_Post_prev(ctx, field)
	case "related":
		return ec.fieldContext_Post_related(ctx, field)
	case "comments":
		return ec.fieldContext_Post_comments(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Post", field.Name)
}

func (ec *executionContext) childFields_Stat(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "key":
		return ec.fieldContext_Stat_key(ctx, field)
	case "value":
		return ec.fieldContext_Stat_value(ctx, field)
	case "when":
		return ec.fieldContext_Stat_when(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Stat", field.Name)
}

func (ec *executionContext) childFields_Tweet(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Tweet_id(ctx, field)
	case "text":
		return ec.fieldContext_Tweet_text(ctx, field)
	case "hashtags":
		return ec.fieldContext_Tweet_hashtags(ctx, field)
	case "symbols":
		return ec.fieldContext_Tweet_symbols(ctx, field)
	case "user_mentions":
		return ec.fieldContext_Tweet_user_mentions(ctx, field)
	case "urls":
		return ec.fieldContext_Tweet_urls(ctx, field)
	case "screen_name":
		return ec.fieldContext_Tweet_screen_name(ctx, field)
	case "favorite_count":
		return ec.fieldContext_Tweet_favorite_count(ctx, field)
	case "retweet_count":
		return ec.fieldContext_Tweet_retweet_count(ctx, field)
	case "posted":
		return ec.fieldContext_Tweet_posted(ctx, field)
	case "uri":
		return ec.fieldContext_Tweet_uri(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Tweet", field.Name)
}

func (ec *executionContext) childFields_TwitterURL(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "link":
		return ec.fieldContext_TwitterURL_link(ctx, field)
	case "tweetIDs":
		return ec.fieldContext_TwitterURL_tweetIDs(ctx, field)
	case "createdAt":
		return ec.fieldContext_TwitterURL_createdAt(ctx, field)
	case "modifiedAt":
		return ec.fieldContext_TwitterURL_modifiedAt(ctx, field)
	case "tweets":
		return ec.fieldContext_TwitterURL_tweets(ctx, field)
	case "uri":
		return ec.fieldContext_TwitterURL_uri(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type TwitterURL", field.Name)
}

func (ec *executionContext) childFields_User(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_User_id(ctx, field)
	case "role":
		return ec.fieldContext_User_role(ctx, field)
	case "apikey":
		return ec.fieldContext_User_apikey(ctx, field)
	case "name":
		return ec.fieldContext_User_name(ctx, field)
	case "created":
		return ec.fieldContext_User_created(ctx, field)
	case "modified":
		return ec.fieldContext_User_modified(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
}

func (ec *executionContext) childFields___Directive(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext___Directive_name(ctx, field)
	case "description":
		return ec.fieldContext___Directive_description(ctx, field)
	case "isRepeatable":
		return ec.fieldContext___Directive_isRepeatable(ctx, field)
	case "locations":
		return ec.fieldContext___Directive_locations(ctx, field)
	case "args":
		return ec.fieldContext___Directive_args(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
}

func (ec *executionContext) childFields___EnumValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext___EnumValue_name(ctx, field)
	case "description":
		return ec.fieldContext___EnumValue_description(ctx, field)
	case "isDeprecated":
		return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
	case "deprecationReason":
		return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
}

func (ec *executionContext) childFields___Field(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext___Field_name(ctx, field)
	case "description":
		return ec.fieldContext___Field_description(ctx, field)
	case "args":
		return ec.fieldContext___Field_args(ctx, field)
	case "type":
		return ec.fieldContext___Field_type(ctx, field)
	case "isDeprecated":
		return ec.fieldContext___Field_isDeprecated(ctx, field)
	case "deprecationReason":
		return ec.fieldContext___Field_deprecationReason(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
}

func (ec *executionContext) childFields___InputValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext___InputValue_name(ctx, field)
	case "description":
		return ec.fieldContext___InputValue_description(ctx, field)
	case "type":
		return ec.fieldContext___InputValue_type(ctx, field)
	case "defaultValue":
		return ec.fieldContext___InputValue_defaultValue(ctx, field)
	case "isDeprecated":
		return ec.fieldContext___InputValue_isDeprecated(ctx, field)
	case "deprecationReason":
		return ec.fieldContext___InputValue_deprecationReason(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
}

func (ec *executionContext) childFields___Schema(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "description":
		return ec.fieldContext___Schema_description(ctx, field)
	case "types":
		return ec.fieldContext___Schema_types(ctx, field)
	case "queryType":
		return ec.fieldContext___Schema_queryType(ctx, field)
	case "mutationType":
		return ec.fieldContext___Schema_mutationType(ctx, field)
	case "subscriptionType":
		return ec.fieldContext___Schema_subscriptionType(ctx, field)
	case "directives":
		return ec.fieldContext___Schema_directives(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
}

func (ec *executionContext) childFields___Type(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "kind":
		return ec.fieldContext___Type_kind(ctx, field)
	case "name":
		return ec.fieldContext___Type_name(ctx, field)
	case "description":
		return ec.fieldContext___Type_description(ctx, field)
	case "specifiedByURL":
		return ec.fieldContext___Type_specifiedByURL(ctx, field)
	case "fields":
		return ec.fieldContext___Type_fields(ctx, field)
	case "interfaces":
		return ec.fieldContext___Type_interfaces(ctx, field)
	case "possibleTypes":
		return ec.fieldContext___Type_possibleTypes(ctx, field)
	case "enumValues":
		return ec.fieldContext___Type_enumValues(ctx, field)
	case "inputFields":
		return ec.fieldContext___Type_inputFields(ctx, field)
	case "ofType":
		return ec.fieldContext___Type_ofType(ctx, field)
	case "isOneOf":
		return ec.fieldContext___Type_isOneOf(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
}

// endregion ************************** generated!.gotpl **************************

// region    ***************************** args.gotpl *****************************

func (ec *executionContext) dir_hasRole_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "role",
		func(ctx context.Context, v any) (Role, error) {
			return ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["role"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (AddComment, error) {
			return ec.unmarshalNAddComment2githubᚗcomᚋiccoᚋgraphqlᚐAddComment(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createPost_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (EditPost, error) {
			return ec.unmarshalNEditPost2githubᚗcomᚋiccoᚋgraphqlᚐEditPost(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_editPost_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (EditPost, error) {
			return ec.unmarshalNEditPost2githubᚗcomᚋiccoᚋgraphqlᚐEditPost(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_insertLog_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (NewLog, error) {
			return ec.unmarshalNNewLog2githubᚗcomᚋiccoᚋgraphqlᚐNewLog(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_upsertBook_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (EditBook, error) {
			return ec.unmarshalNEditBook2githubᚗcomᚋiccoᚋgraphqlᚐEditBook(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_upsertLink_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (NewLink, error) {
			return ec.unmarshalNNewLink2githubᚗcomᚋiccoᚋgraphqlᚐNewLink(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_upsertStat_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (NewStat, error) {
			return ec.unmarshalNNewStat2githubᚗcomᚋiccoᚋgraphqlᚐNewStat(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_upsertTweet_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (NewTweet, error) {
			return ec.unmarshalNNewTweet2githubᚗcomᚋiccoᚋgraphqlᚐNewTweet(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Post_comments_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Post_related_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "name",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["name"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_books_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_comments_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_drafts_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_futurePosts_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_homeTimelineURLs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_link_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (*string, error) {
			return ec.unmarshalOID2ᚖstring(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "url",
		func(ctx context.Context, v any) (*URI, error) {
			return ec.unmarshalOURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["url"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_links_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_log_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_logs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_nextPost_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_photos_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_post_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_postsByTag_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_posts_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_prevPost_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_search_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "query",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["query"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_stat_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "key",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["key"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_stats_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "count",
		func(ctx context.Context, v any) (*int, error) {
			return ec.unmarshalOInt2ᚖint(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["count"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_tweet_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_tweetsByScreenName_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "screen_name",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["screen_name"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_tweets_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input",
		func(ctx context.Context, v any) (*Limit, error) {
			return ec.unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field___Directive_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
		func(ctx context.Context, v any) (*bool, error) {
			return ec.unmarshalOBoolean2ᚖbool(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Field_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
		func(ctx context.Context, v any) (*bool, error) {
			return ec.unmarshalOBoolean2ᚖbool(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
		func(ctx context.Context, v any) (bool, error) {
			return ec.unmarshalOBoolean2bool(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
		func(ctx context.Context, v any) (bool, error) {
			return ec.unmarshalOBoolean2bool(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

// endregion ***************************** args.gotpl *****************************

// region    ************************** directives.gotpl **************************

// endregion ************************** directives.gotpl **************************

// region    **************************** field.gotpl *****************************

func (ec *executionContext) _Book_id(ctx context.Context, field graphql.CollectedField, obj *Book) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Book_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Book_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Book", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Book_uri(ctx context.Context, field graphql.CollectedField, obj *Book) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Book_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Book_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Book", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Book_title(ctx context.Context, field graphql.CollectedField, obj *Book) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Book_title(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Title, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Book_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Book", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Comment_id(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Comment", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Comment_post(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_post(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Post, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Comment_post(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Comment",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Comment_user(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_user(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.User, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *User) graphql.Marshaler {
			return ec.marshalNUser2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐUser(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Comment",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_User(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Comment_content(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_content(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Content, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_content(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Comment", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Comment_created(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Comment", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Comment_modified(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Comment", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Comment_uri(ctx context.Context, field graphql.CollectedField, obj *Comment) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Comment_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Comment_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Comment", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Geo_lat(ctx context.Context, field graphql.CollectedField, obj *Geo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Geo_lat(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Lat, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v float64) graphql.Marshaler {
			return ec.marshalNFloat2float64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Geo_lat(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Geo", field, false, false, errors.New("field of type Float does not have child fields"))
}

func (ec *executionContext) _Geo_long(ctx context.Context, field graphql.CollectedField, obj *Geo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Geo_long(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Long, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v float64) graphql.Marshaler {
			return ec.marshalNFloat2float64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Geo_long(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Geo", field, false, false, errors.New("field of type Float does not have child fields"))
}

func (ec *executionContext) _Link_id(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Link_title(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_title(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Title, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Link_uri(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v URI) graphql.Marshaler {
			return ec.marshalNURI2githubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Link_created(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Link_description(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Link_screenshot(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_screenshot(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Screenshot, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v URI) graphql.Marshaler {
			return ec.marshalNURI2githubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_screenshot(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Link_tags(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_tags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Tags, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Link_modified(ctx context.Context, field graphql.CollectedField, obj *Link) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Link_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Link_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Link", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Log_id(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Log_description(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Log_project(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_project(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Project, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_project(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Log_user(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_user(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.User, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v User) graphql.Marshaler {
			return ec.marshalNUser2githubᚗcomᚋiccoᚋgraphqlᚐUser(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Log",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_User(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Log_duration(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_duration(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Duration()
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v Duration) graphql.Marshaler {
			return ec.marshalODuration2githubᚗcomᚋiccoᚋgraphqlᚐDuration(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Log_duration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, true, false, errors.New("field of type Duration does not have child fields"))
}

func (ec *executionContext) _Log_uri(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Log_sector(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_sector(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Sector, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v Sector) graphql.Marshaler {
			return ec.marshalNSector2githubᚗcomᚋiccoᚋgraphqlᚐSector(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_sector(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type Sector does not have child fields"))
}

func (ec *executionContext) _Log_started(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_started(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Started, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_started(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Log_stopped(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_stopped(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Stopped, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_stopped(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Log_created(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Log_modified(ctx context.Context, field graphql.CollectedField, obj *Log) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Log_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Log_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Log", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Mutation_upsertBook(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_upsertBook(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().UpsertBook(ctx, fc.Args["input"].(EditBook))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Book
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Book
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Book) graphql.Marshaler {
			return ec.marshalNBook2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_upsertBook(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Book(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_upsertBook_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_upsertLink(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_upsertLink(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().UpsertLink(ctx, fc.Args["input"].(NewLink))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Link
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Link
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Link) graphql.Marshaler {
			return ec.marshalNLink2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_upsertLink(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Link(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_upsertLink_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_upsertStat(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_upsertStat(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().UpsertStat(ctx, fc.Args["input"].(NewStat))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Stat
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Stat
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Stat) graphql.Marshaler {
			return ec.marshalNStat2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_upsertStat(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Stat(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_upsertStat_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_upsertTweet(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_upsertTweet(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().UpsertTweet(ctx, fc.Args["input"].(NewTweet))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Tweet
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Tweet
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Tweet) graphql.Marshaler {
			return ec.marshalNTweet2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_upsertTweet(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tweet(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_upsertTweet_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_addComment(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().AddComment(ctx, fc.Args["input"].(AddComment))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.Directives.LoggedIn == nil {
					var zeroVal *Comment
					return zeroVal, errors.New("directive loggedIn is not implemented")
				}
				return ec.Directives.LoggedIn(ctx, nil, directive0)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Comment) graphql.Marshaler {
			return ec.marshalNComment2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Comment(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_addComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_createPost(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_createPost(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().CreatePost(ctx, fc.Args["input"].(EditPost))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Post
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Post
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalNPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_createPost(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createPost_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_editPost(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_editPost(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().EditPost(ctx, fc.Args["input"].(EditPost))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal *Post
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal *Post
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalNPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_editPost(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_editPost_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_insertLog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_insertLog(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().InsertLog(ctx, fc.Args["input"].(NewLog))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.Directives.LoggedIn == nil {
					var zeroVal *Log
					return zeroVal, errors.New("directive loggedIn is not implemented")
				}
				return ec.Directives.LoggedIn(ctx, nil, directive0)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Log) graphql.Marshaler {
			return ec.marshalOLog2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Mutation_insertLog(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Log(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_insertLog_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Photo_id(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Photo_year(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_year(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Year, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int) graphql.Marshaler {
			return ec.marshalNInt2int(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_year(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Photo_content_type(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_content_type(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ContentType, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_content_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Photo_created(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Photo_modified(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Photo_uri(ctx context.Context, field graphql.CollectedField, obj *Photo) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Photo_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Photo_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Photo", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Post_id(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Post_title(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_title(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Title, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Post_content(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_content(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Content, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_content(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Post_summary(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_summary(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Summary(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_summary(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Post_readtime(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_readtime(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Readtime(ctx), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int32) graphql.Marshaler {
			return ec.marshalNInt2int32(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_readtime(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, true, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Post_social_image(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_social_image(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.SocialImage(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_social_image(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Post_datetime(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_datetime(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Datetime, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_datetime(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Post_created(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Post_modified(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Post_draft(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_draft(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Draft, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalNBoolean2bool(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_draft(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) _Post_tags(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_tags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Tags, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Post_links(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_links(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Links, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Link) graphql.Marshaler {
			return ec.marshalNLink2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_links(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Post",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Link(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Post_uri(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Post", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Post_next(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_next(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Next(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Post_next(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Post",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Post_prev(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_prev(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Prev(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Post_prev(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Post",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Post_related(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_related(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.Related(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_related(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Post",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Post_related_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Post_comments(ctx context.Context, field graphql.CollectedField, obj *Post) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Post_comments(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.Comments(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Comment) graphql.Marshaler {
			return ec.marshalNComment2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Post_comments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Post",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Comment(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Post_comments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_books(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_books(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Books(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Book) graphql.Marshaler {
			return ec.marshalNBook2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_books(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Book(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_books_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_links(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_links(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Links(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Link) graphql.Marshaler {
			return ec.marshalNLink2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_links(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Link(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_links_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_link(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_link(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Link(ctx, fc.Args["id"].(*string), fc.Args["url"].(*URI))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Link) graphql.Marshaler {
			return ec.marshalOLink2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_link(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Link(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_link_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_stats(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_stats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Stats(ctx, fc.Args["count"].(*int))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Stat) graphql.Marshaler {
			return ec.marshalNStat2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_stats(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Stat(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_stats_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_stat(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_stat(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Stat(ctx, fc.Args["key"].(string), fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Stat) graphql.Marshaler {
			return ec.marshalNStat2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_stat(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Stat(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_stat_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_counts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_counts(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Counts(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Stat) graphql.Marshaler {
			return ec.marshalNStat2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_counts(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Stat(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_whoami(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_whoami(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Whoami(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *User) graphql.Marshaler {
			return ec.marshalOUser2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐUser(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_whoami(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_User(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_tweets(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_tweets(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Tweets(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Tweet) graphql.Marshaler {
			return ec.marshalNTweet2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_tweets(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tweet(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_tweets_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_tweet(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_tweet(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Tweet(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Tweet) graphql.Marshaler {
			return ec.marshalOTweet2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_tweet(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tweet(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_tweet_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_tweetsByScreenName(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_tweetsByScreenName(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().TweetsByScreenName(ctx, fc.Args["screen_name"].(string), fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Tweet) graphql.Marshaler {
			return ec.marshalNTweet2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_tweetsByScreenName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tweet(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_tweetsByScreenName_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_homeTimelineURLs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_homeTimelineURLs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().HomeTimelineURLs(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*TwitterURL) graphql.Marshaler {
			return ec.marshalNTwitterURL2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTwitterURL(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_homeTimelineURLs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_TwitterURL(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_homeTimelineURLs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_time(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_time(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Time(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *time.Time) graphql.Marshaler {
			return ec.marshalNTime2ᚖtimeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_time(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Query", field, true, true, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Query_drafts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_drafts(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Drafts(ctx, fc.Args["input"].(*Limit))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal []*Post
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal []*Post
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_drafts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_drafts_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_futurePosts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_futurePosts(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().FuturePosts(ctx, fc.Args["input"].(*Limit))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				role, err := ec.unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx, "admin")
				if err != nil {
					var zeroVal []*Post
					return zeroVal, err
				}
				if ec.Directives.HasRole == nil {
					var zeroVal []*Post
					return zeroVal, errors.New("directive hasRole is not implemented")
				}
				return ec.Directives.HasRole(ctx, nil, directive0, role)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_futurePosts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_futurePosts_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_posts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_posts(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Posts(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_posts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_posts_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_comments(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_comments(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Comments(ctx, fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Comment) graphql.Marshaler {
			return ec.marshalNComment2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_comments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Comment(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_comments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_search(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_search(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Search(ctx, fc.Args["query"].(string), fc.Args["input"].(*Limit))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_search(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_search_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_post(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_post(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Post(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_post(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_post_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nextPost(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_nextPost(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NextPost(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_nextPost(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_nextPost_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_prevPost(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_prevPost(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().PrevPost(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *Post) graphql.Marshaler {
			return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_prevPost(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_prevPost_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_postsByTag(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_postsByTag(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().PostsByTag(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Post) graphql.Marshaler {
			return ec.marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_postsByTag(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Post(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_postsByTag_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_tags(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_tags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Tags(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Query", field, true, true, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Query_logs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_logs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Logs(ctx, fc.Args["input"].(*Limit))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.Directives.LoggedIn == nil {
					var zeroVal []*Log
					return zeroVal, errors.New("directive loggedIn is not implemented")
				}
				return ec.Directives.LoggedIn(ctx, nil, directive0)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v []*Log) graphql.Marshaler {
			return ec.marshalNLog2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_logs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Log(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_logs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_log(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_log(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Log(ctx, fc.Args["id"].(string))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.Directives.LoggedIn == nil {
					var zeroVal *Log
					return zeroVal, errors.New("directive loggedIn is not implemented")
				}
				return ec.Directives.LoggedIn(ctx, nil, directive0)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v *Log) graphql.Marshaler {
			return ec.marshalOLog2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_log(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Log(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_log_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_photos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_photos(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Photos(ctx, fc.Args["input"].(*Limit))
		},
		func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
			directive0 := next

			directive1 := func(ctx context.Context) (any, error) {
				if ec.Directives.LoggedIn == nil {
					var zeroVal []*Photo
					return zeroVal, errors.New("directive loggedIn is not implemented")
				}
				return ec.Directives.LoggedIn(ctx, nil, directive0)
			}

			next = directive1
			return next
		},
		func(ctx context.Context, selections ast.SelectionSet, v []*Photo) graphql.Marshaler {
			return ec.marshalNPhoto2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPhoto(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_photos(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Photo(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_photos_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query___type(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.IntrospectType(fc.Args["name"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query___schema(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.IntrospectSchema()
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
			return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Schema(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Stat_key(ctx context.Context, field graphql.CollectedField, obj *Stat) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Stat_key(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Key, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Stat_key(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Stat", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Stat_value(ctx context.Context, field graphql.CollectedField, obj *Stat) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Stat_value(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Value, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v float64) graphql.Marshaler {
			return ec.marshalNFloat2float64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Stat_value(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Stat", field, false, false, errors.New("field of type Float does not have child fields"))
}

func (ec *executionContext) _Stat_when(ctx context.Context, field graphql.CollectedField, obj *Stat) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Stat_when(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.When, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Stat_when(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Stat", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Tweet_id(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Tweet_text(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_text(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Text, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_text(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Tweet_hashtags(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_hashtags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Hashtags, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_hashtags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Tweet_symbols(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_symbols(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Symbols, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_symbols(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Tweet_user_mentions(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_user_mentions(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.UserMentions, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_user_mentions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Tweet_urls(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_urls(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Urls, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*URI) graphql.Marshaler {
			return ec.marshalNURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_urls(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _Tweet_screen_name(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_screen_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ScreenName, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_screen_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Tweet_favorite_count(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_favorite_count(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.FavoriteCount, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int) graphql.Marshaler {
			return ec.marshalNInt2int(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_favorite_count(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Tweet_retweet_count(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_retweet_count(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.RetweetCount, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int) graphql.Marshaler {
			return ec.marshalNInt2int(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_retweet_count(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Tweet_posted(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_posted(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Posted, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_posted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Tweet_uri(ctx context.Context, field graphql.CollectedField, obj *Tweet) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Tweet_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Tweet_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Tweet", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _TwitterURL_link(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_link(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Link, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalOURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_link(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TwitterURL", field, false, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _TwitterURL_tweetIDs(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_tweetIDs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.TweetIDs, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalNID2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_tweetIDs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TwitterURL", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _TwitterURL_createdAt(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_createdAt(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.CreatedAt, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TwitterURL", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _TwitterURL_modifiedAt(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_modifiedAt(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ModifiedAt, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_modifiedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TwitterURL", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _TwitterURL_tweets(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_tweets(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Tweets(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*Tweet) graphql.Marshaler {
			return ec.marshalNTweet2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_tweets(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "TwitterURL",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tweet(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _TwitterURL_uri(ctx context.Context, field graphql.CollectedField, obj *TwitterURL) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TwitterURL_uri(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.URI(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *URI) graphql.Marshaler {
			return ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TwitterURL_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TwitterURL", field, true, false, errors.New("field of type URI does not have child fields"))
}

func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _User_role(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_role(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Role, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_role(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _User_apikey(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_apikey(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.APIKey, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_apikey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_created(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Created, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _User_modified(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_User_modified(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Modified, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
			return ec.marshalNTime2timeᚐTime(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_User_modified(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Directive_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Directive_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Directive_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Directive_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Directive", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Directive_isRepeatable(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.IsRepeatable, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalNBoolean2bool(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Directive_isRepeatable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Directive_locations(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Locations, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
			return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Directive_locations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type __DirectiveLocation does not have child fields"))
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Directive_args(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Args, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
			return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___InputValue(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Directive_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___EnumValue_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___EnumValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__EnumValue", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___EnumValue_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___EnumValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalNBoolean2bool(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___EnumValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___EnumValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Field_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Field", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Field_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_args(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Args, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
			return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___InputValue(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Field_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_type(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Type, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Field_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_isDeprecated(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalNBoolean2bool(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Field_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Field_deprecationReason(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNString2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___InputValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__InputValue", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___InputValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_type(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Type, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___InputValue_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_defaultValue(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.DefaultValue, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___InputValue_defaultValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__InputValue", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___InputValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_isDeprecated(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.IsDeprecated(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalNBoolean2bool(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___InputValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) ___InputValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___InputValue_deprecationReason(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.DeprecationReason(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___InputValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Schema_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Schema", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_types(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Types(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
			return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Schema_types(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_queryType(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.QueryType(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Schema_queryType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_mutationType(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.MutationType(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Schema_mutationType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_subscriptionType(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.SubscriptionType(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Schema_subscriptionType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Schema_directives(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Directives(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
			return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Schema_directives(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Directive(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_kind(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Kind(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalN__TypeKind2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext___Type_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type __TypeKind does not have child fields"))
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_name(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Name(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_description(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Description(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_specifiedByURL(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.SpecifiedByURL(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
			return ec.marshalOString2ᚖstring(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_fields(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
			return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Field(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_interfaces(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Interfaces(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_interfaces(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_possibleTypes(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.PossibleTypes(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_possibleTypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_enumValues(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
			return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___EnumValue(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_inputFields(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.InputFields(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
			return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_inputFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___InputValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_ofType(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.OfType(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
			return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_ofType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields___Type(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_isOneOf(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext___Type_isOneOf(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.IsOneOf(), nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
			return ec.marshalOBoolean2bool(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext___Type_isOneOf(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type Boolean does not have child fields"))
}

// endregion **************************** field.gotpl *****************************

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputAddComment(ctx context.Context, obj any) (AddComment, error) {
	var it AddComment
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"content", "post_id"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "content":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("content"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Content = data
		case "post_id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("post_id"))
			data, err := ec.unmarshalNID2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.PostID = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputEditBook(ctx context.Context, obj any) (EditBook, error) {
	var it EditBook
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "title", "goodreads_id"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			data, err := ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ID = data
		case "title":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Title = data
		case "goodreads_id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("goodreads_id"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.GoodreadsID = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputEditPost(ctx context.Context, obj any) (EditPost, error) {
	var it EditPost
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "content", "title", "datetime", "draft"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			data, err := ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ID = data
		case "content":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("content"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Content = data
		case "title":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Title = data
		case "datetime":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("datetime"))
			data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.Datetime = data
		case "draft":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("draft"))
			data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
			it.Draft = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputInputGeo(ctx context.Context, obj any) (InputGeo, error) {
	var it InputGeo
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"lat", "long"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "lat":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lat"))
			data, err := ec.unmarshalNFloat2float64(ctx, v)
			if err != nil {
				return it, err
			}
			it.Lat = data
		case "long":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("long"))
			data, err := ec.unmarshalNFloat2float64(ctx, v)
			if err != nil {
				return it, err
			}
			it.Long = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputLimit(ctx context.Context, obj any) (Limit, error) {
	var it Limit
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"limit", "offset"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "limit":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.Limit = data
		case "offset":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.Offset = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputNewLink(ctx context.Context, obj any) (NewLink, error) {
	var it NewLink
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"title", "uri", "description", "tags", "created"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "title":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Title = data
		case "uri":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uri"))
			data, err := ec.unmarshalNURI2githubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, v)
			if err != nil {
				return it, err
			}
			it.URI = data
		case "description":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Description = data
		case "tags":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags"))
			data, err := ec.unmarshalNString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Tags = data
		case "created":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("created"))
			data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.Created = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputNewLog(ctx context.Context, obj any) (NewLog, error) {
	var it NewLog
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"sector", "description", "project", "started", "stopped"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "sector":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sector"))
			data, err := ec.unmarshalNSector2githubᚗcomᚋiccoᚋgraphqlᚐSector(ctx, v)
			if err != nil {
				return it, err
			}
			it.Sector = data
		case "description":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Description = data
		case "project":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("project"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Project = data
		case "started":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("started"))
			data, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.Started = data
		case "stopped":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stopped"))
			data, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.Stopped = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputNewStat(ctx context.Context, obj any) (NewStat, error) {
	var it NewStat
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"key", "value"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "key":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Key = data
		case "value":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
			data, err := ec.unmarshalNFloat2float64(ctx, v)
			if err != nil {
				return it, err
			}
			it.Value = data
		}
	}
	return it, nil
}

func (ec *executionContext) unmarshalInputNewTweet(ctx context.Context, obj any) (NewTweet, error) {
	var it NewTweet
	if obj == nil {
		return it, nil
	}

	asMap := map[string]any{}
	for k, v := range obj.(map[string]any) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"favorite_count", "hashtags", "id", "posted", "retweet_count", "symbols", "text", "urls", "screen_name", "user_mentions"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "favorite_count":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("favorite_count"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.FavoriteCount = data
		case "hashtags":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hashtags"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Hashtags = data
		case "id":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			data, err := ec.unmarshalNID2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.ID = data
		case "posted":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("posted"))
			data, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.Posted = data
		case "retweet_count":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("retweet_count"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.RetweetCount = data
		case "symbols":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("symbols"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Symbols = data
		case "text":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Text = data
		case "urls":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("urls"))
			data, err := ec.unmarshalOURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Urls = data
		case "screen_name":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("screen_name"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.ScreenName = data
		case "user_mentions":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user_mentions"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.UserMentions = data
		}
	}
	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

func (ec *executionContext) _Linkable(ctx context.Context, sel ast.SelectionSet, obj Linkable) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case *TwitterURL:
		if obj == nil {
			return graphql.Null
		}
		return ec._TwitterURL(ctx, sel, obj)
	case *Tweet:
		if obj == nil {
			return graphql.Null
		}
		return ec._Tweet(ctx, sel, obj)
	case *Post:
		if obj == nil {
			return graphql.Null
		}
		return ec._Post(ctx, sel, obj)
	case *Photo:
		if obj == nil {
			return graphql.Null
		}
		return ec._Photo(ctx, sel, obj)
	case *Log:
		if obj == nil {
			return graphql.Null
		}
		return ec._Log(ctx, sel, obj)
	case *Link:
		if obj == nil {
			return graphql.Null
		}
		return ec._Link(ctx, sel, obj)
	case *Comment:
		if obj == nil {
			return graphql.Null
		}
		return ec._Comment(ctx, sel, obj)
	case *Book:
		if obj == nil {
			return graphql.Null
		}
		return ec._Book(ctx, sel, obj)
	default:
		if typedObj, ok := obj.(graphql.Marshaler); ok {
			return typedObj
		} else {
			panic(fmt.Errorf("unexpected type %T; non-generated variants of Linkable must implement graphql.Marshaler", obj))
		}
	}
}

func (ec *executionContext) _Searchable(ctx context.Context, sel ast.SelectionSet, obj Searchable) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	default:
		if typedObj, ok := obj.(graphql.Marshaler); ok {
			return typedObj
		} else {
			panic(fmt.Errorf("unexpected type %T; non-generated variants of Searchable must implement graphql.Marshaler", obj))
		}
	}
}

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var bookImplementors = []string{"Book", "Linkable"}

func (ec *executionContext) _Book(ctx context.Context, sel ast.SelectionSet, obj *Book) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bookImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Book")
		case "id":
			out.Values[i] = ec._Book_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "uri":
			out.Values[i] = ec._Book_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "title":
			out.Values[i] = ec._Book_title(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var commentImplementors = []string{"Comment", "Linkable"}

func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *Comment) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Comment")
		case "id":
			out.Values[i] = ec._Comment_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "post":
			out.Values[i] = ec._Comment_post(ctx, field, obj)
		case "user":
			out.Values[i] = ec._Comment_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "content":
			out.Values[i] = ec._Comment_content(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "created":
			out.Values[i] = ec._Comment_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "modified":
			out.Values[i] = ec._Comment_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "uri":
			out.Values[i] = ec._Comment_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var geoImplementors = []string{"Geo"}

func (ec *executionContext) _Geo(ctx context.Context, sel ast.SelectionSet, obj *Geo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, geoImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Geo")
		case "lat":
			out.Values[i] = ec._Geo_lat(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "long":
			out.Values[i] = ec._Geo_long(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var linkImplementors = []string{"Link", "Linkable"}

func (ec *executionContext) _Link(ctx context.Context, sel ast.SelectionSet, obj *Link) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, linkImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Link")
		case "id":
			out.Values[i] = ec._Link_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "title":
			out.Values[i] = ec._Link_title(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "uri":
			out.Values[i] = ec._Link_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "created":
			out.Values[i] = ec._Link_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec._Link_description(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "screenshot":
			out.Values[i] = ec._Link_screenshot(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "tags":
			out.Values[i] = ec._Link_tags(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "modified":
			out.Values[i] = ec._Link_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var logImplementors = []string{"Log", "Linkable"}

func (ec *executionContext) _Log(ctx context.Context, sel ast.SelectionSet, obj *Log) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, logImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Log")
		case "id":
			out.Values[i] = ec._Log_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec._Log_description(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "project":
			out.Values[i] = ec._Log_project(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "user":
			out.Values[i] = ec._Log_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "duration":
			out.Values[i] = ec._Log_duration(ctx, field, obj)
		case "uri":
			out.Values[i] = ec._Log_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "sector":
			out.Values[i] = ec._Log_sector(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "started":
			out.Values[i] = ec._Log_started(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "stopped":
			out.Values[i] = ec._Log_stopped(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "created":
			out.Values[i] = ec._Log_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "modified":
			out.Values[i] = ec._Log_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var mutationImplementors = []string{"Mutation"}

func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Mutation",
	})

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Mutation")
		case "upsertBook":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_upsertBook(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "upsertLink":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_upsertLink(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "upsertStat":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_upsertStat(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "upsertTweet":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_upsertTweet(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "addComment":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_addComment(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "createPost":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createPost(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "editPost":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_editPost(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "insertLog":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_insertLog(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var photoImplementors = []string{"Photo", "Linkable"}

func (ec *executionContext) _Photo(ctx context.Context, sel ast.SelectionSet, obj *Photo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, photoImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Photo")
		case "id":
			out.Values[i] = ec._Photo_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "year":
			out.Values[i] = ec._Photo_year(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "content_type":
			out.Values[i] = ec._Photo_content_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "created":
			out.Values[i] = ec._Photo_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "modified":
			out.Values[i] = ec._Photo_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "uri":
			out.Values[i] = ec._Photo_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var postImplementors = []string{"Post", "Linkable"}

func (ec *executionContext) _Post(ctx context.Context, sel ast.SelectionSet, obj *Post) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, postImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Post")
		case "id":
			out.Values[i] = ec._Post_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "title":
			out.Values[i] = ec._Post_title(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "content":
			out.Values[i] = ec._Post_content(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "summary":
			out.Values[i] = ec._Post_summary(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "readtime":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_readtime(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "social_image":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_social_image(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "datetime":
			out.Values[i] = ec._Post_datetime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "created":
			out.Values[i] = ec._Post_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "modified":
			out.Values[i] = ec._Post_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "draft":
			out.Values[i] = ec._Post_draft(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "tags":
			out.Values[i] = ec._Post_tags(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "links":
			out.Values[i] = ec._Post_links(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "uri":
			out.Values[i] = ec._Post_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "next":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_next(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "prev":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_prev(ctx, field, obj)
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "related":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_related(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "comments":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Post_comments(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var queryImplementors = []string{"Query"}

func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Query",
	})

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "books":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_books(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "links":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_links(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "link":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_link(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "stats":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_stats(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "stat":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_stat(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "counts":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_counts(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "whoami":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_whoami(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "tweets":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tweets(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "tweet":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tweet(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "tweetsByScreenName":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tweetsByScreenName(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "homeTimelineURLs":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_homeTimelineURLs(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "time":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_time(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "drafts":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_drafts(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "futurePosts":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_futurePosts(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "posts":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_posts(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "comments":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_comments(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "search":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_search(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "post":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_post(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "nextPost":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_nextPost(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "prevPost":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_prevPost(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "postsByTag":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_postsByTag(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "tags":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tags(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "logs":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_logs(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "log":
			field := field

			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_log(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "photos":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_photos(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "__type":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___type(ctx, field)
			})
		case "__schema":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___schema(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var statImplementors = []string{"Stat"}

func (ec *executionContext) _Stat(ctx context.Context, sel ast.SelectionSet, obj *Stat) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, statImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Stat")
		case "key":
			out.Values[i] = ec._Stat_key(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "value":
			out.Values[i] = ec._Stat_value(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "when":
			out.Values[i] = ec._Stat_when(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var tweetImplementors = []string{"Tweet", "Linkable"}

func (ec *executionContext) _Tweet(ctx context.Context, sel ast.SelectionSet, obj *Tweet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tweetImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Tweet")
		case "id":
			out.Values[i] = ec._Tweet_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "text":
			out.Values[i] = ec._Tweet_text(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "hashtags":
			out.Values[i] = ec._Tweet_hashtags(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "symbols":
			out.Values[i] = ec._Tweet_symbols(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "user_mentions":
			out.Values[i] = ec._Tweet_user_mentions(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "urls":
			out.Values[i] = ec._Tweet_urls(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "screen_name":
			out.Values[i] = ec._Tweet_screen_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "favorite_count":
			out.Values[i] = ec._Tweet_favorite_count(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "retweet_count":
			out.Values[i] = ec._Tweet_retweet_count(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "posted":
			out.Values[i] = ec._Tweet_posted(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "uri":
			out.Values[i] = ec._Tweet_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var twitterURLImplementors = []string{"TwitterURL", "Linkable"}

func (ec *executionContext) _TwitterURL(ctx context.Context, sel ast.SelectionSet, obj *TwitterURL) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, twitterURLImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TwitterURL")
		case "link":
			out.Values[i] = ec._TwitterURL_link(ctx, field, obj)
		case "tweetIDs":
			out.Values[i] = ec._TwitterURL_tweetIDs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "createdAt":
			out.Values[i] = ec._TwitterURL_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "modifiedAt":
			out.Values[i] = ec._TwitterURL_modifiedAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "tweets":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TwitterURL_tweets(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.Deferrable != nil {
				dfs, ok := deferred[field.Deferrable.Label]
				di := 0
				if ok {
					dfs.AddField(field)
					di = len(dfs.Values) - 1
				} else {
					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
					deferred[field.Deferrable.Label] = dfs
				}
				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, dfs)
				})

				// don't run the out.Concurrently() call below
				out.Values[i] = graphql.Null
				continue
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
		case "uri":
			out.Values[i] = ec._TwitterURL_uri(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var userImplementors = []string{"User"}

func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("User")
		case "id":
			out.Values[i] = ec._User_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "role":
			out.Values[i] = ec._User_role(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "apikey":
			out.Values[i] = ec._User_apikey(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._User_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "created":
			out.Values[i] = ec._User_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "modified":
			out.Values[i] = ec._User_modified(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __DirectiveImplementors = []string{"__Directive"}

func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Directive")
		case "name":
			out.Values[i] = ec.___Directive_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___Directive_description(ctx, field, obj)
		case "isRepeatable":
			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "locations":
			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __EnumValueImplementors = []string{"__EnumValue"}

func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__EnumValue")
		case "name":
			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __FieldImplementors = []string{"__Field"}

func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Field")
		case "name":
			out.Values[i] = ec.___Field_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___Field_description(ctx, field, obj)
		case "args":
			out.Values[i] = ec.___Field_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __InputValueImplementors = []string{"__InputValue"}

func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__InputValue")
		case "name":
			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
		case "type":
			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___InputValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___InputValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __SchemaImplementors = []string{"__Schema"}

func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "description":
			out.Values[i] = ec.___Schema_description(ctx, field, obj)
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "mutationType":
			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
		case "directives":
			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var __TypeImplementors = []string{"__Type"}

func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Type")
		case "kind":
			out.Values[i] = ec.___Type_kind(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec.___Type_name(ctx, field, obj)
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
		case "specifiedByURL":
			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
		case "isOneOf":
			out.Values[i] = ec.___Type_isOneOf(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.Deferred, int32(min(len(deferred), math.MaxInt32)))

	for label, dfs := range deferred {
		ec.ProcessDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) unmarshalNAddComment2githubᚗcomᚋiccoᚋgraphqlᚐAddComment(ctx context.Context, v any) (AddComment, error) {
	res, err := ec.unmarshalInputAddComment(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBook2githubᚗcomᚋiccoᚋgraphqlᚐBook(ctx context.Context, sel ast.SelectionSet, v Book) graphql.Marshaler {
	return ec._Book(ctx, sel, &v)
}

func (ec *executionContext) marshalNBook2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx context.Context, sel ast.SelectionSet, v []*Book) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOBook2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNBook2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx context.Context, sel ast.SelectionSet, v *Book) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Book(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v any) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalBoolean(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalNComment2githubᚗcomᚋiccoᚋgraphqlᚐComment(ctx context.Context, sel ast.SelectionSet, v Comment) graphql.Marshaler {
	return ec._Comment(ctx, sel, &v)
}

func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx context.Context, sel ast.SelectionSet, v []*Comment) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOComment2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx context.Context, sel ast.SelectionSet, v *Comment) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Comment(ctx, sel, v)
}

func (ec *executionContext) unmarshalNEditBook2githubᚗcomᚋiccoᚋgraphqlᚐEditBook(ctx context.Context, v any) (EditBook, error) {
	res, err := ec.unmarshalInputEditBook(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNEditPost2githubᚗcomᚋiccoᚋgraphqlᚐEditPost(ctx context.Context, v any) (EditPost, error) {
	res, err := ec.unmarshalInputEditPost(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v any) (float64, error) {
	res, err := graphql.UnmarshalFloatContext(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalFloatContext(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return graphql.WrapContextMarshaler(ctx, res)
}

func (ec *executionContext) unmarshalNID2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalID(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalID(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNID2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNID2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNID2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNID2string(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v any) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalInt(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNInt2int32(ctx context.Context, v any) (int32, error) {
	res, err := graphql.UnmarshalInt32(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInt2int32(ctx context.Context, sel ast.SelectionSet, v int32) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalInt32(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalNLink2githubᚗcomᚋiccoᚋgraphqlᚐLink(ctx context.Context, sel ast.SelectionSet, v Link) graphql.Marshaler {
	return ec._Link(ctx, sel, &v)
}

func (ec *executionContext) marshalNLink2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx context.Context, sel ast.SelectionSet, v []*Link) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOLink2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNLink2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx context.Context, sel ast.SelectionSet, v *Link) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Link(ctx, sel, v)
}

func (ec *executionContext) marshalNLog2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx context.Context, sel ast.SelectionSet, v []*Log) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOLog2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) unmarshalNNewLink2githubᚗcomᚋiccoᚋgraphqlᚐNewLink(ctx context.Context, v any) (NewLink, error) {
	res, err := ec.unmarshalInputNewLink(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNNewLog2githubᚗcomᚋiccoᚋgraphqlᚐNewLog(ctx context.Context, v any) (NewLog, error) {
	res, err := ec.unmarshalInputNewLog(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNNewStat2githubᚗcomᚋiccoᚋgraphqlᚐNewStat(ctx context.Context, v any) (NewStat, error) {
	res, err := ec.unmarshalInputNewStat(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNNewTweet2githubᚗcomᚋiccoᚋgraphqlᚐNewTweet(ctx context.Context, v any) (NewTweet, error) {
	res, err := ec.unmarshalInputNewTweet(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNPhoto2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPhoto(ctx context.Context, sel ast.SelectionSet, v []*Photo) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOPhoto2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPhoto(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNPost2githubᚗcomᚋiccoᚋgraphqlᚐPost(ctx context.Context, sel ast.SelectionSet, v Post) graphql.Marshaler {
	return ec._Post(ctx, sel, &v)
}

func (ec *executionContext) marshalNPost2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx context.Context, sel ast.SelectionSet, v []*Post) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx context.Context, sel ast.SelectionSet, v *Post) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Post(ctx, sel, v)
}

func (ec *executionContext) unmarshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx context.Context, v any) (Role, error) {
	var res Role
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNRole2githubᚗcomᚋiccoᚋgraphqlᚐRole(ctx context.Context, sel ast.SelectionSet, v Role) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNSector2githubᚗcomᚋiccoᚋgraphqlᚐSector(ctx context.Context, v any) (Sector, error) {
	var res Sector
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSector2githubᚗcomᚋiccoᚋgraphqlᚐSector(ctx context.Context, sel ast.SelectionSet, v Sector) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNStat2githubᚗcomᚋiccoᚋgraphqlᚐStat(ctx context.Context, sel ast.SelectionSet, v Stat) graphql.Marshaler {
	return ec._Stat(ctx, sel, &v)
}

func (ec *executionContext) marshalNStat2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx context.Context, sel ast.SelectionSet, v []*Stat) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOStat2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNStat2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx context.Context, sel ast.SelectionSet, v *Stat) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Stat(ctx, sel, v)
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v any) (time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalTime(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v any) (*time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	_ = sel
	res := graphql.MarshalTime(*v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalNTweet2githubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx context.Context, sel ast.SelectionSet, v Tweet) graphql.Marshaler {
	return ec._Tweet(ctx, sel, &v)
}

func (ec *executionContext) marshalNTweet2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx context.Context, sel ast.SelectionSet, v []*Tweet) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOTweet2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalNTweet2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx context.Context, sel ast.SelectionSet, v *Tweet) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Tweet(ctx, sel, v)
}

func (ec *executionContext) marshalNTwitterURL2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐTwitterURL(ctx context.Context, sel ast.SelectionSet, v []*TwitterURL) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalOTwitterURL2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTwitterURL(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) unmarshalNURI2githubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, v any) (URI, error) {
	var res URI
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNURI2githubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, sel ast.SelectionSet, v URI) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx context.Context, v any) ([]*URI, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]*URI, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx context.Context, sel ast.SelectionSet, v []*URI) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, v any) (*URI, error) {
	var res = new(URI)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, sel ast.SelectionSet, v *URI) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalNUser2githubᚗcomᚋiccoᚋgraphqlᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
	return ec._User(ctx, sel, &v)
}

func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._User(ctx, sel, v)
}

func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
	return ec.___Directive(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
	return ec.___EnumValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
	return ec.___Field(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
	return ec.___InputValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalOBook2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐBook(ctx context.Context, sel ast.SelectionSet, v *Book) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Book(ctx, sel, v)
}

func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v any) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	_ = sel
	_ = ctx
	res := graphql.MarshalBoolean(v)
	return res
}

func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v any) (*bool, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalBoolean(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalBoolean(*v)
	return res
}

func (ec *executionContext) marshalOComment2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐComment(ctx context.Context, sel ast.SelectionSet, v *Comment) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Comment(ctx, sel, v)
}

func (ec *executionContext) unmarshalODuration2githubᚗcomᚋiccoᚋgraphqlᚐDuration(ctx context.Context, v any) (Duration, error) {
	var res Duration
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalODuration2githubᚗcomᚋiccoᚋgraphqlᚐDuration(ctx context.Context, sel ast.SelectionSet, v Duration) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalOID2ᚖstring(ctx context.Context, v any) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalID(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOID2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalID(*v)
	return res
}

func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v any) (*int, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalInt(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalInt(*v)
	return res
}

func (ec *executionContext) unmarshalOLimit2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLimit(ctx context.Context, v any) (*Limit, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputLimit(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOLink2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLink(ctx context.Context, sel ast.SelectionSet, v *Link) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Link(ctx, sel, v)
}

func (ec *executionContext) marshalOLog2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐLog(ctx context.Context, sel ast.SelectionSet, v *Log) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Log(ctx, sel, v)
}

func (ec *executionContext) marshalOPhoto2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPhoto(ctx context.Context, sel ast.SelectionSet, v *Photo) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Photo(ctx, sel, v)
}

func (ec *executionContext) marshalOPost2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐPost(ctx context.Context, sel ast.SelectionSet, v *Post) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Post(ctx, sel, v)
}

func (ec *executionContext) marshalOStat2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐStat(ctx context.Context, sel ast.SelectionSet, v *Stat) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Stat(ctx, sel, v)
}

func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v any) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalString(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalString(*v)
	return res
}

func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v any) (*time.Time, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalTime(*v)
	return res
}

func (ec *executionContext) marshalOTweet2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTweet(ctx context.Context, sel ast.SelectionSet, v *Tweet) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Tweet(ctx, sel, v)
}

func (ec *executionContext) marshalOTwitterURL2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐTwitterURL(ctx context.Context, sel ast.SelectionSet, v *TwitterURL) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._TwitterURL(ctx, sel, v)
}

func (ec *executionContext) unmarshalOURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx context.Context, v any) ([]*URI, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []any
	vSlice = graphql.CoerceList(v)
	var err error
	res := make([]*URI, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOURI2ᚕᚖgithubᚗcomᚋiccoᚋgraphqlᚐURIᚄ(ctx context.Context, sel ast.SelectionSet, v []*URI) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, v any) (*URI, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(URI)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOURI2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐURI(ctx context.Context, sel ast.SelectionSet, v *URI) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋiccoᚋgraphqlᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._User(ctx, sel, v)
}

func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Schema(ctx, sel, v)
}

func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
		fc := graphql.GetFieldContext(ctx)
		fc.Result = &v[i]
		return ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
	})

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

// endregion ***************************** type.gotpl *****************************