func (ec *executionContext) field_Mutation_createTodo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 model.NewTodo
	if tmp, ok := rawArgs["input"]; ok {
		arg0, err = ec.unmarshalNNewTodo2githubᚗcomᚋsteinfletcherᚋapitestᚋexamplesᚋgraphqlᚋgraphᚋmodelᚐNewTodo(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}
endregion ************************** generated!.gotpl **************************
region    ***************************** args.gotpl *****************************
package generated
import (
	"bytes"
	"context"
	"errors"
	"strconv"
	"sync"
	"sync/atomic"
	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	"github.com/steinfletcher/apitest/examples/graphql/graph/model"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{
		resolvers:  cfg.Resolvers,
		directives: cfg.Directives,
		complexity: cfg.Complexity,
	}
}
type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}
type ResolverRoot interface {
	Mutation() MutationResolver
	Query() QueryResolver
}
type DirectiveRoot struct {
}
type ComplexityRoot struct {
	Mutation struct {
		CreateTodo func(childComplexity int, input model.NewTodo) int
	}
	Query struct {
		Todos func(childComplexity int) int
	}
	Todo struct {
		Done func(childComplexity int) int
		ID   func(childComplexity int) int
		Text func(childComplexity int) int
		User func(childComplexity int) int
	}
	User struct {
		ID   func(childComplexity int) int
		Name func(childComplexity int) int
	}
}
type MutationResolver interface {
	CreateTodo(ctx context.Context, input model.NewTodo) (*model.Todo, error)
}
type QueryResolver interface {
	Todos(ctx context.Context) ([]*model.Todo, error)
}
type executableSchema struct {
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}
func (e *executableSchema) Schema() *ast.Schema {
	return parsedSchema
}
func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e}
	_ = ec
	switch typeName + "." + field {
	case "Mutation.createTodo":
		if e.complexity.Mutation.CreateTodo == nil {
			break
		}
		args, err := ec.field_Mutation_createTodo_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}
		return e.complexity.Mutation.CreateTodo(childComplexity, args["input"].(model.NewTodo)), true
	case "Query.todos":
		if e.complexity.Query.Todos == nil {
			break
		}
		return e.complexity.Query.Todos(childComplexity), true
	case "Todo.done":
		if e.complexity.Todo.Done == nil {
			break
		}
		return e.complexity.Todo.Done(childComplexity), true
	case "Todo.id":
		if e.complexity.Todo.ID == nil {
			break
		}
		return e.complexity.Todo.ID(childComplexity), true
	case "Todo.text":
		if e.complexity.Todo.Text == nil {
			break
		}
		return e.complexity.Todo.Text(childComplexity), true
	case "Todo.user":
		if e.complexity.Todo.User == nil {
			break
		}
		return e.complexity.Todo.User(childComplexity), true
	case "User.id":
		if e.complexity.User.ID == nil {
			break
		}
		return e.complexity.User.ID(childComplexity), true
	case "User.name":
		if e.complexity.User.Name == nil {
			break
		}
		return e.complexity.User.Name(childComplexity), true
	}
	return 0, false
}
func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e}
	first := true
	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Query(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}
	case ast.Mutation:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}
	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}
type executionContext struct {
	*graphql.OperationContext
	*executableSchema
}
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(parsedSchema), nil
}
func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
}
var sources = []*ast.Source{
	&ast.Source{Name: "graph/schema.graphqls", Input: `# GraphQL schema example
#
# https: 
type Todo {
  id: ID!
  text: String!
  done: Boolean!
  user: User!
}
type User {
  id: ID!
  name: String!
}
type Query {
  todos: [Todo!]!
}
input NewTodo {
  text: String!
  userId: String!
}
type Mutation {
  createTodo(input: NewTodo!): Todo!
}`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)