func (ec *executionContext) dir_deprecated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["reason"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("reason"))
		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["reason"] = arg0
	return args, nil
}
endregion ************************** generated!.gotpl **************************
region    ***************************** args.gotpl *****************************
package search
import (
	"bytes"
	"context"
	"errors"
	"strconv"
	"sync"
	"time"
	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	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 {
	Query() QueryResolver
}
type DirectiveRoot struct {
	Deprecated func(ctx context.Context, obj interface{}, next graphql.Resolver, reason *string) (res interface{}, err error)
	Include    func(ctx context.Context, obj interface{}, next graphql.Resolver, ifArg bool) (res interface{}, err error)
	Skip       func(ctx context.Context, obj interface{}, next graphql.Resolver, ifArg bool) (res interface{}, err error)
}
type ComplexityRoot struct {
	Cve struct {
		Description func(childComplexity int) int
		ID          func(childComplexity int) int
		PackageList func(childComplexity int) int
		Severity    func(childComplexity int) int
		Title       func(childComplexity int) int
	}
	CVEResultForImage struct {
		CVEList func(childComplexity int) int
		Tag     func(childComplexity int) int
	}
	ImageInfo struct {
		Description func(childComplexity int) int
		Labels      func(childComplexity int) int
		LastUpdated func(childComplexity int) int
		Latest      func(childComplexity int) int
		Licenses    func(childComplexity int) int
		Name        func(childComplexity int) int
		Size        func(childComplexity int) int
		Vendor      func(childComplexity int) int
	}
	ImgResultForCve struct {
		Name func(childComplexity int) int
		Tags func(childComplexity int) int
	}
	ImgResultForDigest struct {
		Name func(childComplexity int) int
		Tags func(childComplexity int) int
	}
	ImgResultForFixedCve struct {
		Tags func(childComplexity int) int
	}
	PackageInfo struct {
		FixedVersion     func(childComplexity int) int
		InstalledVersion func(childComplexity int) int
		Name             func(childComplexity int) int
	}
	Query struct {
		CVEListForImage        func(childComplexity int, image string) int
		ImageListForCve        func(childComplexity int, id string) int
		ImageListForDigest     func(childComplexity int, id string) int
		ImageListWithCVEFixed  func(childComplexity int, id string, image string) int
		ImageListWithLatestTag func(childComplexity int) int
	}
	TagInfo struct {
		Digest    func(childComplexity int) int
		Name      func(childComplexity int) int
		Timestamp func(childComplexity int) int
	}
}
type QueryResolver interface {
	CVEListForImage(ctx context.Context, image string) (*CVEResultForImage, error)
	ImageListForCve(ctx context.Context, id string) ([]*ImgResultForCve, error)
	ImageListWithCVEFixed(ctx context.Context, id string, image string) (*ImgResultForFixedCve, error)
	ImageListForDigest(ctx context.Context, id string) ([]*ImgResultForDigest, error)
	ImageListWithLatestTag(ctx context.Context) ([]*ImageInfo, 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 "CVE.Description":
		if e.complexity.Cve.Description == nil {
			break
		}
		return e.complexity.Cve.Description(childComplexity), true
	case "CVE.Id":
		if e.complexity.Cve.ID == nil {
			break
		}
		return e.complexity.Cve.ID(childComplexity), true
	case "CVE.PackageList":
		if e.complexity.Cve.PackageList == nil {
			break
		}
		return e.complexity.Cve.PackageList(childComplexity), true
	case "CVE.Severity":
		if e.complexity.Cve.Severity == nil {
			break
		}
		return e.complexity.Cve.Severity(childComplexity), true
	case "CVE.Title":
		if e.complexity.Cve.Title == nil {
			break
		}
		return e.complexity.Cve.Title(childComplexity), true
	case "CVEResultForImage.CVEList":
		if e.complexity.CVEResultForImage.CVEList == nil {
			break
		}
		return e.complexity.CVEResultForImage.CVEList(childComplexity), true
	case "CVEResultForImage.Tag":
		if e.complexity.CVEResultForImage.Tag == nil {
			break
		}
		return e.complexity.CVEResultForImage.Tag(childComplexity), true
	case "ImageInfo.Description":
		if e.complexity.ImageInfo.Description == nil {
			break
		}
		return e.complexity.ImageInfo.Description(childComplexity), true
	case "ImageInfo.Labels":
		if e.complexity.ImageInfo.Labels == nil {
			break
		}
		return e.complexity.ImageInfo.Labels(childComplexity), true
	case "ImageInfo.LastUpdated":
		if e.complexity.ImageInfo.LastUpdated == nil {
			break
		}
		return e.complexity.ImageInfo.LastUpdated(childComplexity), true
	case "ImageInfo.Latest":
		if e.complexity.ImageInfo.Latest == nil {
			break
		}
		return e.complexity.ImageInfo.Latest(childComplexity), true
	case "ImageInfo.Licenses":
		if e.complexity.ImageInfo.Licenses == nil {
			break
		}
		return e.complexity.ImageInfo.Licenses(childComplexity), true
	case "ImageInfo.Name":
		if e.complexity.ImageInfo.Name == nil {
			break
		}
		return e.complexity.ImageInfo.Name(childComplexity), true
	case "ImageInfo.Size":
		if e.complexity.ImageInfo.Size == nil {
			break
		}
		return e.complexity.ImageInfo.Size(childComplexity), true
	case "ImageInfo.Vendor":
		if e.complexity.ImageInfo.Vendor == nil {
			break
		}
		return e.complexity.ImageInfo.Vendor(childComplexity), true
	case "ImgResultForCVE.Name":
		if e.complexity.ImgResultForCve.Name == nil {
			break
		}
		return e.complexity.ImgResultForCve.Name(childComplexity), true
	case "ImgResultForCVE.Tags":
		if e.complexity.ImgResultForCve.Tags == nil {
			break
		}
		return e.complexity.ImgResultForCve.Tags(childComplexity), true
	case "ImgResultForDigest.Name":
		if e.complexity.ImgResultForDigest.Name == nil {
			break
		}
		return e.complexity.ImgResultForDigest.Name(childComplexity), true
	case "ImgResultForDigest.Tags":
		if e.complexity.ImgResultForDigest.Tags == nil {
			break
		}
		return e.complexity.ImgResultForDigest.Tags(childComplexity), true
	case "ImgResultForFixedCVE.Tags":
		if e.complexity.ImgResultForFixedCve.Tags == nil {
			break
		}
		return e.complexity.ImgResultForFixedCve.Tags(childComplexity), true
	case "PackageInfo.FixedVersion":
		if e.complexity.PackageInfo.FixedVersion == nil {
			break
		}
		return e.complexity.PackageInfo.FixedVersion(childComplexity), true
	case "PackageInfo.InstalledVersion":
		if e.complexity.PackageInfo.InstalledVersion == nil {
			break
		}
		return e.complexity.PackageInfo.InstalledVersion(childComplexity), true
	case "PackageInfo.Name":
		if e.complexity.PackageInfo.Name == nil {
			break
		}
		return e.complexity.PackageInfo.Name(childComplexity), true
	case "Query.CVEListForImage":
		if e.complexity.Query.CVEListForImage == nil {
			break
		}
		args, err := ec.field_Query_CVEListForImage_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}
		return e.complexity.Query.CVEListForImage(childComplexity, args["image"].(string)), true
	case "Query.ImageListForCVE":
		if e.complexity.Query.ImageListForCve == nil {
			break
		}
		args, err := ec.field_Query_ImageListForCVE_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}
		return e.complexity.Query.ImageListForCve(childComplexity, args["id"].(string)), true
	case "Query.ImageListForDigest":
		if e.complexity.Query.ImageListForDigest == nil {
			break
		}
		args, err := ec.field_Query_ImageListForDigest_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}
		return e.complexity.Query.ImageListForDigest(childComplexity, args["id"].(string)), true
	case "Query.ImageListWithCVEFixed":
		if e.complexity.Query.ImageListWithCVEFixed == nil {
			break
		}
		args, err := ec.field_Query_ImageListWithCVEFixed_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}
		return e.complexity.Query.ImageListWithCVEFixed(childComplexity, args["id"].(string), args["image"].(string)), true
	case "Query.ImageListWithLatestTag":
		if e.complexity.Query.ImageListWithLatestTag == nil {
			break
		}
		return e.complexity.Query.ImageListWithLatestTag(childComplexity), true
	case "TagInfo.Digest":
		if e.complexity.TagInfo.Digest == nil {
			break
		}
		return e.complexity.TagInfo.Digest(childComplexity), true
	case "TagInfo.Name":
		if e.complexity.TagInfo.Name == nil {
			break
		}
		return e.complexity.TagInfo.Name(childComplexity), true
	case "TagInfo.Timestamp":
		if e.complexity.TagInfo.Timestamp == nil {
			break
		}
		return e.complexity.TagInfo.Timestamp(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(),
			}
		}
	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{
	{Name: "schema.graphql", Input: `scalar Time
type CVEResultForImage {
     Tag: String 
     CVEList: [CVE]
}
type CVE {
     Id: String 
     Title: String
     Description: String
     Severity: String
     PackageList: [PackageInfo]
}
type PackageInfo {
     Name: String 
     InstalledVersion: String 
     FixedVersion: String 
}
type ImgResultForCVE {
     Name: String 
     Tags: [String]
}
type ImgResultForFixedCVE {
     Tags: [TagInfo]
}
type ImgResultForDigest {
     Name: String
     Tags: [String]
}
type TagInfo {
     Name: String
     Digest: String
     Timestamp: Time
}
type ImageInfo {
     Name: String
     Latest: String
     LastUpdated: Time
     Description: String
     Licenses: String
     Vendor: String
     Size: String
     Labels: String
}
type Query {
  CVEListForImage(image: String!) :CVEResultForImage 
  ImageListForCVE(id: String!) :[ImgResultForCVE]
  ImageListWithCVEFixed(id: String!, image: String!) :ImgResultForFixedCVE
  ImageListForDigest(id: String!) :[ImgResultForDigest]
  ImageListWithLatestTag:[ImageInfo]
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)