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

package api

import (
	"bytes"
	"context"
	"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"
	"sourcecraft.dev/bigbes/sr-ht-core/model"
	model1 "sourcecraft.dev/bigbes/sr-ht-dolt/graph/model"
)

// region    ***************************** api!.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 {
	Database() DatabaseResolver
	Query() QueryResolver
}

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	ACLEntry struct {
		Mode func(childComplexity int) int
		User func(childComplexity int) int
	}

	Branch struct {
		Head func(childComplexity int) int
		Name func(childComplexity int) int
	}

	Column struct {
		Name       func(childComplexity int) int
		Nullable   func(childComplexity int) int
		PrimaryKey func(childComplexity int) int
		Type       func(childComplexity int) int
	}

	Commit struct {
		Author  func(childComplexity int) int
		Date    func(childComplexity int) int
		Email   func(childComplexity int) int
		Hash    func(childComplexity int) int
		Message func(childComplexity int) int
		Parents func(childComplexity int) int
	}

	CommitCursor struct {
		Cursor  func(childComplexity int) int
		Results func(childComplexity int) int
	}

	Database struct {
		ACL           func(childComplexity int) int
		Branches      func(childComplexity int) int
		Created       func(childComplexity int) int
		DefaultBranch func(childComplexity int) int
		Description   func(childComplexity int) int
		ID            func(childComplexity int) int
		Log           func(childComplexity int, ref *string, from *model.Cursor, limit *int) int
		Name          func(childComplexity int) int
		Owner         func(childComplexity int) int
		Tables        func(childComplexity int, ref *string) int
		Updated       func(childComplexity int) int
		Visibility    func(childComplexity int) int
	}

	DatabaseCursor struct {
		Cursor  func(childComplexity int) int
		Results func(childComplexity int) int
	}

	Query struct {
		Database         func(childComplexity int, owner string, name string) int
		Databases        func(childComplexity int, cursor *model.Cursor, filter *model.Filter) int
		DatabasesByOwner func(childComplexity int, owner string, cursor *model.Cursor, filter *model.Filter) int
		Me               func(childComplexity int) int
	}

	Table struct {
		Columns  func(childComplexity int) int
		Name     func(childComplexity int) int
		RowCount func(childComplexity int) int
	}

	User struct {
		CanonicalName func(childComplexity int) int
		Username      func(childComplexity int) int
	}
}

// endregion ***************************** api!.gotpl *****************************

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

type DatabaseResolver interface {
	DefaultBranch(ctx context.Context, obj *model1.Database) (*string, error)
	Branches(ctx context.Context, obj *model1.Database) ([]*model1.Branch, error)
	Log(ctx context.Context, obj *model1.Database, ref *string, from *model.Cursor, limit *int) (*model1.CommitCursor, error)
	Tables(ctx context.Context, obj *model1.Database, ref *string) ([]*model1.Table, error)
	ACL(ctx context.Context, obj *model1.Database) ([]*model1.ACLEntry, error)
}
type QueryResolver interface {
	Me(ctx context.Context) (*model1.User, error)
	Databases(ctx context.Context, cursor *model.Cursor, filter *model.Filter) (*model1.DatabaseCursor, error)
	DatabasesByOwner(ctx context.Context, owner string, cursor *model.Cursor, filter *model.Filter) (*model1.DatabaseCursor, error)
	Database(ctx context.Context, owner string, name string) (*model1.Database, error)
}

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

// region    ************************** internal!.gotpl ***************************

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 "ACLEntry.mode":
		if e.ComplexityRoot.ACLEntry.Mode == nil {
			break
		}

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

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

	case "Branch.head":
		if e.ComplexityRoot.Branch.Head == nil {
			break
		}

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

		return e.ComplexityRoot.Branch.Name(childComplexity), true

	case "Column.name":
		if e.ComplexityRoot.Column.Name == nil {
			break
		}

		return e.ComplexityRoot.Column.Name(childComplexity), true
	case "Column.nullable":
		if e.ComplexityRoot.Column.Nullable == nil {
			break
		}

		return e.ComplexityRoot.Column.Nullable(childComplexity), true
	case "Column.primaryKey":
		if e.ComplexityRoot.Column.PrimaryKey == nil {
			break
		}

		return e.ComplexityRoot.Column.PrimaryKey(childComplexity), true
	case "Column.type":
		if e.ComplexityRoot.Column.Type == nil {
			break
		}

		return e.ComplexityRoot.Column.Type(childComplexity), true

	case "Commit.author":
		if e.ComplexityRoot.Commit.Author == nil {
			break
		}

		return e.ComplexityRoot.Commit.Author(childComplexity), true
	case "Commit.date":
		if e.ComplexityRoot.Commit.Date == nil {
			break
		}

		return e.ComplexityRoot.Commit.Date(childComplexity), true
	case "Commit.email":
		if e.ComplexityRoot.Commit.Email == nil {
			break
		}

		return e.ComplexityRoot.Commit.Email(childComplexity), true
	case "Commit.hash":
		if e.ComplexityRoot.Commit.Hash == nil {
			break
		}

		return e.ComplexityRoot.Commit.Hash(childComplexity), true
	case "Commit.message":
		if e.ComplexityRoot.Commit.Message == nil {
			break
		}

		return e.ComplexityRoot.Commit.Message(childComplexity), true
	case "Commit.parents":
		if e.ComplexityRoot.Commit.Parents == nil {
			break
		}

		return e.ComplexityRoot.Commit.Parents(childComplexity), true

	case "CommitCursor.cursor":
		if e.ComplexityRoot.CommitCursor.Cursor == nil {
			break
		}

		return e.ComplexityRoot.CommitCursor.Cursor(childComplexity), true
	case "CommitCursor.results":
		if e.ComplexityRoot.CommitCursor.Results == nil {
			break
		}

		return e.ComplexityRoot.CommitCursor.Results(childComplexity), true

	case "Database.acl":
		if e.ComplexityRoot.Database.ACL == nil {
			break
		}

		return e.ComplexityRoot.Database.ACL(childComplexity), true
	case "Database.branches":
		if e.ComplexityRoot.Database.Branches == nil {
			break
		}

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

		return e.ComplexityRoot.Database.Created(childComplexity), true
	case "Database.defaultBranch":
		if e.ComplexityRoot.Database.DefaultBranch == nil {
			break
		}

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

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

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

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

		return e.ComplexityRoot.Database.Log(childComplexity, args["ref"].(*string), args["from"].(*model.Cursor), args["limit"].(*int)), true
	case "Database.name":
		if e.ComplexityRoot.Database.Name == nil {
			break
		}

		return e.ComplexityRoot.Database.Name(childComplexity), true
	case "Database.owner":
		if e.ComplexityRoot.Database.Owner == nil {
			break
		}

		return e.ComplexityRoot.Database.Owner(childComplexity), true
	case "Database.tables":
		if e.ComplexityRoot.Database.Tables == nil {
			break
		}

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

		return e.ComplexityRoot.Database.Tables(childComplexity, args["ref"].(*string)), true
	case "Database.updated":
		if e.ComplexityRoot.Database.Updated == nil {
			break
		}

		return e.ComplexityRoot.Database.Updated(childComplexity), true
	case "Database.visibility":
		if e.ComplexityRoot.Database.Visibility == nil {
			break
		}

		return e.ComplexityRoot.Database.Visibility(childComplexity), true

	case "DatabaseCursor.cursor":
		if e.ComplexityRoot.DatabaseCursor.Cursor == nil {
			break
		}

		return e.ComplexityRoot.DatabaseCursor.Cursor(childComplexity), true
	case "DatabaseCursor.results":
		if e.ComplexityRoot.DatabaseCursor.Results == nil {
			break
		}

		return e.ComplexityRoot.DatabaseCursor.Results(childComplexity), true

	case "Query.database":
		if e.ComplexityRoot.Query.Database == nil {
			break
		}

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

		return e.ComplexityRoot.Query.Database(childComplexity, args["owner"].(string), args["name"].(string)), true
	case "Query.databases":
		if e.ComplexityRoot.Query.Databases == nil {
			break
		}

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

		return e.ComplexityRoot.Query.Databases(childComplexity, args["cursor"].(*model.Cursor), args["filter"].(*model.Filter)), true
	case "Query.databasesByOwner":
		if e.ComplexityRoot.Query.DatabasesByOwner == nil {
			break
		}

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

		return e.ComplexityRoot.Query.DatabasesByOwner(childComplexity, args["owner"].(string), args["cursor"].(*model.Cursor), args["filter"].(*model.Filter)), true

	case "Query.me":
		if e.ComplexityRoot.Query.Me == nil {
			break
		}

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

	case "Table.columns":
		if e.ComplexityRoot.Table.Columns == nil {
			break
		}

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

		return e.ComplexityRoot.Table.Name(childComplexity), true
	case "Table.rowCount":
		if e.ComplexityRoot.Table.RowCount == nil {
			break
		}

		return e.ComplexityRoot.Table.RowCount(childComplexity), true

	case "User.canonicalName":
		if e.ComplexityRoot.User.CanonicalName == nil {
			break
		}

		return e.ComplexityRoot.User.CanonicalName(childComplexity), true
	case "User.username":
		if e.ComplexityRoot.User.Username == nil {
			break
		}

		return e.ComplexityRoot.User.Username(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.unmarshalInputFilter,
	)
	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
		}

	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,
		),
	}
}

var sources = []*ast.Source{
	{Name: "../schema.graphqls", Input: `# dolt.sr.ht — the read schema.
#
# There are no mutations here, and the reason is the same one spec.sr.ht gives:
# a type federated into api.sr.ht is a consumed contract, expensive to churn, so
# only what has settled is published. Creating, renaming and deleting a database
# each move a metadata row and an on-disk store together, and that pairing is
# young; it stays behind the web UI until it is not.
#
# Rows and diffs are absent for a different reason. They exist on /mcp, where a
# read that had to be clipped says so in its own answer — a shape this schema
# would have to reproduce field by field to stay honest. Until it does, a client
# that wants table contents should ask /mcp, and this schema stops at the
# structure: what databases exist, what branches and commits they carry, and
# what tables live at a ref.
#
# Everything below is read through the same db/ store and browse/ session the
# web pages and the MCP tools use, so the three surfaces cannot disagree about
# what a database is.

"""
An RFC-3339 timestamp.
"""
scalar Time

"""
An opaque pagination cursor. Pass it back into the same field to fetch the next
page; it is null when there are no further results.
"""
scalar Cursor

"""
Who may see a database, and how it is listed.

PUBLIC is listed to everyone including anonymous callers. UNLISTED is reachable
by direct address but never appears in a listing to a stranger. PRIVATE is
neither: to a caller who may not see it, it does not exist — this schema answers
null rather than an authorization error, exactly as the web UI answers "no such
database" rather than "forbidden".
"""
enum Visibility {
  PUBLIC
  UNLISTED
  PRIVATE
}

"""
An ACL grant: read-only (browse and clone) or read-write (and push).
"""
enum AccessMode {
  RO
  RW
}

"""
A SourceHut account, mirrored from meta.sr.ht.
"""
type User {
  """
  The username with no leading "~". This is the name that addresses the account
  in ` + "`" + `database(owner:)` + "`" + ` and in a clone URL's path.
  """
  username: String!

  """
  The username with its leading "~", as SourceHut writes it in prose and in the
  web UI.
  """
  canonicalName: String!
}

"""
A hosted Dolt database: one metadata row and one bare chunk store.
"""
type Database {
  id: Int!
  name: String!
  owner: User!

  """
  The description shown in listings. Empty rather than null when unset: a
  companion of a git repository mirrors that repository's description, and "no
  description" and "the empty description" are the same state here.
  """
  description: String!
  visibility: Visibility!
  created: Time!
  updated: Time!

  """
  The branch a reader lands on: "main" when it exists, else the first branch by
  name. Null for a database nothing has been pushed to yet — a store with no
  commits has no branches, which is a state and not a failure.
  """
  defaultBranch: String

  """
  Every branch, the default one first and the rest by name. Empty for a database
  nothing has been pushed to.
  """
  branches: [Branch!]!

  """
  The commit log of ` + "`" + `ref` + "`" + `, newest first. ` + "`" + `ref` + "`" + ` is a branch name or a commit
  hash, defaulting to ` + "`" + `defaultBranch` + "`" + `; ` + "`" + `from` + "`" + ` continues a previous page from the
  hash it returned as ` + "`" + `cursor` + "`" + `.
  """
  log(ref: String, from: Cursor, limit: Int): CommitCursor!

  """
  The tables of the committed root at ` + "`" + `ref` + "`" + ` (a branch name or a commit hash,
  defaulting to ` + "`" + `defaultBranch` + "`" + `), each with its columns and row count.
  """
  tables(ref: String): [Table!]!

  """
  Who else may read or write this database. Owner-only: to anybody else it is
  the empty list, because the collaborator list of a database you do not own is
  not yours to enumerate.
  """
  acl: [ACLEntry!]!
}

"""
A branch and the commit it points at.
"""
type Branch {
  name: String!
  head: String!
}

"""
One commit of a database's history.
"""
type Commit {
  hash: String!
  author: String!
  email: String!
  date: Time!
  message: String!
  parents: [String!]!
}

"""
A column of a table, as the stored schema declares it.
"""
type Column {
  name: String!
  type: String!
  primaryKey: Boolean!
  nullable: Boolean!
}

"""
A table at a ref: its schema and how many rows it holds there.
"""
type Table {
  name: String!
  columns: [Column!]!
  rowCount: Int!
}

"""
An access grant on a database.
"""
type ACLEntry {
  user: User!
  mode: AccessMode!
}

"""
How a listing is paged. It is git.sr.ht's ` + "`" + `Filter` + "`" + ` minus ` + "`" + `search` + "`" + `: nothing here
searches yet, and declaring a field this schema would ignore is a worse answer
than not declaring it.
"""
input Filter {
  """
  How many results one page holds, capped at 100. It travels in the cursor the
  page returns, so it is given once and kept for the rest of the walk.
  """
  count: Int = 25
}

type DatabaseCursor {
  results: [Database!]!
  cursor: Cursor
}

type CommitCursor {
  results: [Commit!]!
  cursor: Cursor
}

type Query {
  """
  The caller, or null for an anonymous one. Anonymous is a normal caller on this
  schema — it reads what an anonymous visitor reads — so a null here is an
  answer and not an error.
  """
  me: User

  """
  Every database the caller may be shown, newest first, across all owners.

  This is the listing rule and not the read rule: PUBLIC to everyone, plus
  whatever the caller owns or holds an ACL entry on. An UNLISTED database of
  somebody else is absent here and still readable through ` + "`" + `database` + "`" + `.
  """
  databases(cursor: Cursor, filter: Filter): DatabaseCursor!

  """
  One owner's databases, under the same listing rule as ` + "`" + `databases` + "`" + `. ` + "`" + `owner` + "`" + `
  carries no leading "~".
  """
  databasesByOwner(owner: String!, cursor: Cursor, filter: Filter): DatabaseCursor!

  """
  One database by owner and name, neither carrying a leading "~". Null when
  there is no such database *or* when the caller may not see it — the two are
  deliberately one answer, so that a PRIVATE database cannot be discovered by
  the shape of the refusal.
  """
  database(owner: String!, name: String!): Database
}
`, 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_ACLEntry(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "user":
		return ec.fieldContext_ACLEntry_user(ctx, field)
	case "mode":
		return ec.fieldContext_ACLEntry_mode(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type ACLEntry", field.Name)
}

func (ec *executionContext) childFields_Branch(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_Branch_name(ctx, field)
	case "head":
		return ec.fieldContext_Branch_head(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Branch", field.Name)
}

func (ec *executionContext) childFields_Column(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_Column_name(ctx, field)
	case "type":
		return ec.fieldContext_Column_type(ctx, field)
	case "primaryKey":
		return ec.fieldContext_Column_primaryKey(ctx, field)
	case "nullable":
		return ec.fieldContext_Column_nullable(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Column", field.Name)
}

func (ec *executionContext) childFields_Commit(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "hash":
		return ec.fieldContext_Commit_hash(ctx, field)
	case "author":
		return ec.fieldContext_Commit_author(ctx, field)
	case "email":
		return ec.fieldContext_Commit_email(ctx, field)
	case "date":
		return ec.fieldContext_Commit_date(ctx, field)
	case "message":
		return ec.fieldContext_Commit_message(ctx, field)
	case "parents":
		return ec.fieldContext_Commit_parents(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Commit", field.Name)
}

func (ec *executionContext) childFields_CommitCursor(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "results":
		return ec.fieldContext_CommitCursor_results(ctx, field)
	case "cursor":
		return ec.fieldContext_CommitCursor_cursor(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type CommitCursor", field.Name)
}

func (ec *executionContext) childFields_Database(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Database_id(ctx, field)
	case "name":
		return ec.fieldContext_Database_name(ctx, field)
	case "owner":
		return ec.fieldContext_Database_owner(ctx, field)
	case "description":
		return ec.fieldContext_Database_description(ctx, field)
	case "visibility":
		return ec.fieldContext_Database_visibility(ctx, field)
	case "created":
		return ec.fieldContext_Database_created(ctx, field)
	case "updated":
		return ec.fieldContext_Database_updated(ctx, field)
	case "defaultBranch":
		return ec.fieldContext_Database_defaultBranch(ctx, field)
	case "branches":
		return ec.fieldContext_Database_branches(ctx, field)
	case "log":
		return ec.fieldContext_Database_log(ctx, field)
	case "tables":
		return ec.fieldContext_Database_tables(ctx, field)
	case "acl":
		return ec.fieldContext_Database_acl(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Database", field.Name)
}

func (ec *executionContext) childFields_DatabaseCursor(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "results":
		return ec.fieldContext_DatabaseCursor_results(ctx, field)
	case "cursor":
		return ec.fieldContext_DatabaseCursor_cursor(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type DatabaseCursor", field.Name)
}

func (ec *executionContext) childFields_Table(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_Table_name(ctx, field)
	case "columns":
		return ec.fieldContext_Table_columns(ctx, field)
	case "rowCount":
		return ec.fieldContext_Table_rowCount(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Table", field.Name)
}

func (ec *executionContext) childFields_User(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "username":
		return ec.fieldContext_User_username(ctx, field)
	case "canonicalName":
		return ec.fieldContext_User_canonicalName(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 ************************** internal!.gotpl ***************************

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

func (ec *executionContext) field_Database_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, "ref",
		func(ctx context.Context, v any) (*string, error) {
			return ec.unmarshalOString2ᚖstring(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["ref"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "from",
		func(ctx context.Context, v any) (*model.Cursor, error) {
			return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["from"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "limit",
		func(ctx context.Context, v any) (*int, error) {
			return ec.unmarshalOInt2ᚖint(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["limit"] = arg2
	return args, nil
}

func (ec *executionContext) field_Database_tables_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, "ref",
		func(ctx context.Context, v any) (*string, error) {
			return ec.unmarshalOString2ᚖstring(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["ref"] = 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_database_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, "owner",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["owner"] = arg0
	arg1, 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"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_databasesByOwner_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, "owner",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["owner"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "cursor",
		func(ctx context.Context, v any) (*model.Cursor, error) {
			return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cursor"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "filter",
		func(ctx context.Context, v any) (*model.Filter, error) {
			return ec.unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_databases_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, "cursor",
		func(ctx context.Context, v any) (*model.Cursor, error) {
			return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cursor"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "filter",
		func(ctx context.Context, v any) (*model.Filter, error) {
			return ec.unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg1
	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    **************************** field.gotpl *****************************

func (ec *executionContext) _ACLEntry_user(ctx context.Context, field graphql.CollectedField, obj *model1.ACLEntry) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ACLEntry_user(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.User, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
			return ec.marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_ACLEntry_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ACLEntry",
		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) _ACLEntry_mode(ctx context.Context, field graphql.CollectedField, obj *model1.ACLEntry) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ACLEntry_mode(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Mode, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v model1.AccessMode) graphql.Marshaler {
			return ec.marshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_ACLEntry_mode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("ACLEntry", field, false, false, errors.New("field of type AccessMode does not have child fields"))
}

func (ec *executionContext) _Branch_name(ctx context.Context, field graphql.CollectedField, obj *model1.Branch) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Branch_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_Branch_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Branch", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Branch_head(ctx context.Context, field graphql.CollectedField, obj *model1.Branch) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Branch_head(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Head, 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_Branch_head(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Branch", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Column_name(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Column_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_Column_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Column_type(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Column_type(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Type, 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_Column_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Column_primaryKey(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Column_primaryKey(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.PrimaryKey, 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_Column_primaryKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) _Column_nullable(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Column_nullable(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Nullable, 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_Column_nullable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type Boolean does not have child fields"))
}

func (ec *executionContext) _Commit_hash(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_hash(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Hash, 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_Commit_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Commit_author(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_author(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Author, 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_Commit_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Commit_email(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_email(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Email, 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_Commit_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Commit_date(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_date(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Date, 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_Commit_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Commit_message(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_message(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Message, 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_Commit_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Commit_parents(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Commit_parents(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Parents, 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_Commit_parents(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _CommitCursor_results(ctx context.Context, field graphql.CollectedField, obj *model1.CommitCursor) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_CommitCursor_results(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Results, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.Commit) graphql.Marshaler {
			return ec.marshalNCommit2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_CommitCursor_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CommitCursor",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Commit(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CommitCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model1.CommitCursor) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_CommitCursor_cursor(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
			return ec.marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_CommitCursor_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("CommitCursor", field, false, false, errors.New("field of type Cursor does not have child fields"))
}

func (ec *executionContext) _Database_id(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, 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_Database_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Database_name(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_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_Database_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Database_owner(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_owner(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Owner, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
			return ec.marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Database",
		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) _Database_description(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_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_Database_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Database_visibility(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_visibility(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Visibility, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v model1.Visibility) graphql.Marshaler {
			return ec.marshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_visibility(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Visibility does not have child fields"))
}

func (ec *executionContext) _Database_created(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_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_Database_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Database_updated(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_updated(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Updated, 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_Database_updated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Time does not have child fields"))
}

func (ec *executionContext) _Database_defaultBranch(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_defaultBranch(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Database().DefaultBranch(ctx, obj)
		},
		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_Database_defaultBranch(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Database", field, true, true, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Database_branches(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_branches(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Database().Branches(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.Branch) graphql.Marshaler {
			return ec.marshalNBranch2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranchᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_branches(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Database",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Branch(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Database_log(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_log(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Database().Log(ctx, obj, fc.Args["ref"].(*string), fc.Args["from"].(*model.Cursor), fc.Args["limit"].(*int))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.CommitCursor) graphql.Marshaler {
			return ec.marshalNCommitCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_log(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Database",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_CommitCursor(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_Database_log_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Database_tables(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_tables(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Database().Tables(ctx, obj, fc.Args["ref"].(*string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.Table) graphql.Marshaler {
			return ec.marshalNTable2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTableᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_tables(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Database",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Table(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_Database_tables_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Database_acl(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Database_acl(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Database().ACL(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.ACLEntry) graphql.Marshaler {
			return ec.marshalNACLEntry2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntryᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Database_acl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Database",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_ACLEntry(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _DatabaseCursor_results(ctx context.Context, field graphql.CollectedField, obj *model1.DatabaseCursor) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_DatabaseCursor_results(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Results, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.Database) graphql.Marshaler {
			return ec.marshalNDatabase2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_DatabaseCursor_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DatabaseCursor",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Database(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _DatabaseCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model1.DatabaseCursor) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_DatabaseCursor_cursor(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Cursor, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
			return ec.marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_DatabaseCursor_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("DatabaseCursor", field, false, false, errors.New("field of type Cursor does not have child fields"))
}

func (ec *executionContext) _Query_me(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_me(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Me(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
			return ec.marshalOUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_me(_ 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_databases(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_databases(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Databases(ctx, fc.Args["cursor"].(*model.Cursor), fc.Args["filter"].(*model.Filter))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.DatabaseCursor) graphql.Marshaler {
			return ec.marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_databases(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_DatabaseCursor(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_databases_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_databasesByOwner(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_databasesByOwner(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().DatabasesByOwner(ctx, fc.Args["owner"].(string), fc.Args["cursor"].(*model.Cursor), fc.Args["filter"].(*model.Filter))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.DatabaseCursor) graphql.Marshaler {
			return ec.marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_databasesByOwner(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_DatabaseCursor(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_databasesByOwner_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_database(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_database(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Database(ctx, fc.Args["owner"].(string), fc.Args["name"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model1.Database) graphql.Marshaler {
			return ec.marshalODatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_database(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_Database(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_database_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) _Table_name(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Table_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_Table_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Table", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Table_columns(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Table_columns(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Columns, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model1.Column) graphql.Marshaler {
			return ec.marshalNColumn2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumnᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Table_columns(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Table",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Column(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Table_rowCount(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Table_rowCount(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.RowCount, 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_Table_rowCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Table", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _User_username(ctx context.Context, field graphql.CollectedField, obj *model1.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_username(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Username, 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_username(_ 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_canonicalName(ctx context.Context, field graphql.CollectedField, obj *model1.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_canonicalName(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.CanonicalName, 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_canonicalName(_ 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) ___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) unmarshalInputFilter(ctx context.Context, obj any) (model.Filter, error) {
	var it model.Filter
	if obj == nil {
		return it, nil
	}

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

	if _, present := asMap["count"]; !present {
		asMap["count"] = 25
	}

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

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

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

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

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

var aCLEntryImplementors = []string{"ACLEntry"}

func (ec *executionContext) _ACLEntry(ctx context.Context, sel ast.SelectionSet, obj *model1.ACLEntry) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, aCLEntryImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ACLEntry")
		case "user":
			out.Values[i] = ec._ACLEntry_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "mode":
			out.Values[i] = ec._ACLEntry_mode(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var branchImplementors = []string{"Branch"}

func (ec *executionContext) _Branch(ctx context.Context, sel ast.SelectionSet, obj *model1.Branch) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, branchImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Branch")
		case "name":
			out.Values[i] = ec._Branch_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "head":
			out.Values[i] = ec._Branch_head(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var columnImplementors = []string{"Column"}

func (ec *executionContext) _Column(ctx context.Context, sel ast.SelectionSet, obj *model1.Column) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, columnImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Column")
		case "name":
			out.Values[i] = ec._Column_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec._Column_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "primaryKey":
			out.Values[i] = ec._Column_primaryKey(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "nullable":
			out.Values[i] = ec._Column_nullable(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var commitImplementors = []string{"Commit"}

func (ec *executionContext) _Commit(ctx context.Context, sel ast.SelectionSet, obj *model1.Commit) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, commitImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Commit")
		case "hash":
			out.Values[i] = ec._Commit_hash(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "author":
			out.Values[i] = ec._Commit_author(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "email":
			out.Values[i] = ec._Commit_email(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "date":
			out.Values[i] = ec._Commit_date(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "message":
			out.Values[i] = ec._Commit_message(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "parents":
			out.Values[i] = ec._Commit_parents(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var commitCursorImplementors = []string{"CommitCursor"}

func (ec *executionContext) _CommitCursor(ctx context.Context, sel ast.SelectionSet, obj *model1.CommitCursor) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, commitCursorImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CommitCursor")
		case "results":
			out.Values[i] = ec._CommitCursor_results(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._CommitCursor_cursor(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var databaseImplementors = []string{"Database"}

func (ec *executionContext) _Database(ctx context.Context, sel ast.SelectionSet, obj *model1.Database) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, databaseImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Database")
		case "id":
			out.Values[i] = ec._Database_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "name":
			out.Values[i] = ec._Database_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "owner":
			out.Values[i] = ec._Database_owner(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "description":
			out.Values[i] = ec._Database_description(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "visibility":
			out.Values[i] = ec._Database_visibility(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "created":
			out.Values[i] = ec._Database_created(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "updated":
			out.Values[i] = ec._Database_updated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "defaultBranch":
			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._Database_defaultBranch(ctx, field, obj)
				if res == graphql.RequiredNull {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.IsDeferred() {
				deferredFieldSet.AddField(field)
				fieldIndex := len(deferredFieldSet.Values) - 1
				deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, deferredFieldSet)
				})

				for _, deferrable := range field.Deferrables {
					view, ok := deferLabelToView[deferrable.Label]
					if !ok {
						view = deferredFieldSet.NewView()
						deferLabelToView[deferrable.Label] = view
					}
					view.AddIndices(fieldIndex)
				}

				// 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 "branches":
			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._Database_branches(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.IsDeferred() {
				deferredFieldSet.AddField(field)
				fieldIndex := len(deferredFieldSet.Values) - 1
				deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, deferredFieldSet)
				})

				for _, deferrable := range field.Deferrables {
					view, ok := deferLabelToView[deferrable.Label]
					if !ok {
						view = deferredFieldSet.NewView()
						deferLabelToView[deferrable.Label] = view
					}
					view.AddIndices(fieldIndex)
				}

				// 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 "log":
			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._Database_log(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.IsDeferred() {
				deferredFieldSet.AddField(field)
				fieldIndex := len(deferredFieldSet.Values) - 1
				deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, deferredFieldSet)
				})

				for _, deferrable := range field.Deferrables {
					view, ok := deferLabelToView[deferrable.Label]
					if !ok {
						view = deferredFieldSet.NewView()
						deferLabelToView[deferrable.Label] = view
					}
					view.AddIndices(fieldIndex)
				}

				// 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 "tables":
			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._Database_tables(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.IsDeferred() {
				deferredFieldSet.AddField(field)
				fieldIndex := len(deferredFieldSet.Values) - 1
				deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, deferredFieldSet)
				})

				for _, deferrable := range field.Deferrables {
					view, ok := deferLabelToView[deferrable.Label]
					if !ok {
						view = deferredFieldSet.NewView()
						deferLabelToView[deferrable.Label] = view
					}
					view.AddIndices(fieldIndex)
				}

				// 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 "acl":
			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._Database_acl(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			if field.IsDeferred() {
				deferredFieldSet.AddField(field)
				fieldIndex := len(deferredFieldSet.Values) - 1
				deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
					return innerFunc(ctx, deferredFieldSet)
				})

				for _, deferrable := range field.Deferrables {
					view, ok := deferLabelToView[deferrable.Label]
					if !ok {
						view = deferredFieldSet.NewView()
						deferLabelToView[deferrable.Label] = view
					}
					view.AddIndices(fieldIndex)
				}

				// 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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var databaseCursorImplementors = []string{"DatabaseCursor"}

func (ec *executionContext) _DatabaseCursor(ctx context.Context, sel ast.SelectionSet, obj *model1.DatabaseCursor) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, databaseCursorImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DatabaseCursor")
		case "results":
			out.Values[i] = ec._DatabaseCursor_results(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cursor":
			out.Values[i] = ec._DatabaseCursor_cursor(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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 "me":
			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_me(ctx, field)
				if res == graphql.RequiredNull {
					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 "databases":
			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_databases(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 "databasesByOwner":
			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_databasesByOwner(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 "database":
			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_database(ctx, field)
				if res == graphql.RequiredNull {
					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)
			})
			if out.Values[i] == graphql.RequiredNull {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "__schema":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___schema(ctx, field)
			})
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var tableImplementors = []string{"Table"}

func (ec *executionContext) _Table(ctx context.Context, sel ast.SelectionSet, obj *model1.Table) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tableImplementors)

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Table")
		case "name":
			out.Values[i] = ec._Table_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "columns":
			out.Values[i] = ec._Table_columns(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "rowCount":
			out.Values[i] = ec._Table_rowCount(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

var userImplementors = []string{"User"}

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

	out := graphql.NewFieldSet(fields)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("User")
		case "username":
			out.Values[i] = ec._User_username(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "canonicalName":
			out.Values[i] = ec._User_canonicalName(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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		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)
	deferredFieldSet := graphql.NewFieldSet(nil)
	deferLabelToView := make(map[string]*graphql.FieldSetView)
	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)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "specifiedByURL":
			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "isOneOf":
			out.Values[i] = ec.___Type_isOneOf(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				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(deferLabelToView), math.MaxInt32)))

	ec.ProcessDeferredGroup(graphql.DeferredGroup{
		Defers:   deferLabelToView,
		Path:     graphql.GetPath(ctx),
		FieldSet: deferredFieldSet,
		Context:  ctx,
	})

	return out
}

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

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

func (ec *executionContext) marshalNACLEntry2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntryᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.ACLEntry) 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.marshalNACLEntry2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntry(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNACLEntry2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntry(ctx context.Context, sel ast.SelectionSet, v *model1.ACLEntry) 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._ACLEntry(ctx, sel, v)
}

func (ec *executionContext) unmarshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx context.Context, v any) (model1.AccessMode, error) {
	var res model1.AccessMode
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx context.Context, sel ast.SelectionSet, v model1.AccessMode) graphql.Marshaler {
	return 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) marshalNBranch2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranchᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Branch) 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.marshalNBranch2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranch(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNBranch2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranch(ctx context.Context, sel ast.SelectionSet, v *model1.Branch) 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._Branch(ctx, sel, v)
}

func (ec *executionContext) marshalNColumn2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumnᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Column) 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.marshalNColumn2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumn(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNColumn2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumn(ctx context.Context, sel ast.SelectionSet, v *model1.Column) 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._Column(ctx, sel, v)
}

func (ec *executionContext) marshalNCommit2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Commit) 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.marshalNCommit2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommit(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNCommit2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommit(ctx context.Context, sel ast.SelectionSet, v *model1.Commit) 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._Commit(ctx, sel, v)
}

func (ec *executionContext) marshalNCommitCursor2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx context.Context, sel ast.SelectionSet, v model1.CommitCursor) graphql.Marshaler {
	return ec._CommitCursor(ctx, sel, &v)
}

func (ec *executionContext) marshalNCommitCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx context.Context, sel ast.SelectionSet, v *model1.CommitCursor) 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._CommitCursor(ctx, sel, v)
}

func (ec *executionContext) marshalNDatabase2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Database) 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.marshalNDatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNDatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx context.Context, sel ast.SelectionSet, v *model1.Database) 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._Database(ctx, sel, v)
}

func (ec *executionContext) marshalNDatabaseCursor2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx context.Context, sel ast.SelectionSet, v model1.DatabaseCursor) graphql.Marshaler {
	return ec._DatabaseCursor(ctx, sel, &v)
}

func (ec *executionContext) marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx context.Context, sel ast.SelectionSet, v *model1.DatabaseCursor) 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._DatabaseCursor(ctx, sel, v)
}

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) 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) {
	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) marshalNTable2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTableᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Table) 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.marshalNTable2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTable(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNTable2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTable(ctx context.Context, sel ast.SelectionSet, v *model1.Table) 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._Table(ctx, sel, v)
}

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) marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx context.Context, sel ast.SelectionSet, v *model1.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) unmarshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx context.Context, v any) (model1.Visibility, error) {
	var res model1.Visibility
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx context.Context, sel ast.SelectionSet, v model1.Visibility) graphql.Marshaler {
	return 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) {
	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) 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) unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx context.Context, v any) (*model.Cursor, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(model.Cursor)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx context.Context, sel ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalODatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx context.Context, sel ast.SelectionSet, v *model1.Database) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Database(ctx, sel, v)
}

func (ec *executionContext) unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx context.Context, v any) (*model.Filter, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

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) 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) marshalOUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx context.Context, sel ast.SelectionSet, v *model1.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 *****************************