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

package generated

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

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	"github.com/ClusterCockpit/cc-backend/internal/config"
	"github.com/ClusterCockpit/cc-backend/internal/graph/model"
	"github.com/ClusterCockpit/cc-lib/v2/schema"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)

// 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 {
	Cluster() ClusterResolver
	Job() JobResolver
	MetricValue() MetricValueResolver
	Mutation() MutationResolver
	Node() NodeResolver
	Query() QueryResolver
	SubCluster() SubClusterResolver
}

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	Accelerator struct {
		ID    func(childComplexity int) int
		Model func(childComplexity int) int
		Type  func(childComplexity int) int
	}

	Cluster struct {
		Name        func(childComplexity int) int
		Partitions  func(childComplexity int) int
		SubClusters func(childComplexity int) int
	}

	ClusterMetricWithName struct {
		Data     func(childComplexity int) int
		Name     func(childComplexity int) int
		Timestep func(childComplexity int) int
		Unit     func(childComplexity int) int
	}

	ClusterMetrics struct {
		Metrics   func(childComplexity int) int
		NodeCount func(childComplexity int) int
	}

	ClusterSupport struct {
		Cluster     func(childComplexity int) int
		SubClusters func(childComplexity int) int
	}

	Count struct {
		Count func(childComplexity int) int
		Name  func(childComplexity int) int
	}

	EnergyFootprintValue struct {
		Hardware func(childComplexity int) int
		Metric   func(childComplexity int) int
		Value    func(childComplexity int) int
	}

	FootprintValue struct {
		Name  func(childComplexity int) int
		Stat  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	Footprints struct {
		Metrics     func(childComplexity int) int
		TimeWeights func(childComplexity int) int
	}

	GlobalMetricListItem struct {
		Availability func(childComplexity int) int
		Footprint    func(childComplexity int) int
		Name         func(childComplexity int) int
		Scope        func(childComplexity int) int
		Tooltip      func(childComplexity int) int
		Unit         func(childComplexity int) int
	}

	HistoPoint struct {
		Count func(childComplexity int) int
		Value func(childComplexity int) int
	}

	IntRangeOutput struct {
		From func(childComplexity int) int
		To   func(childComplexity int) int
	}

	Job struct {
		ArrayJobID       func(childComplexity int) int
		Cluster          func(childComplexity int) int
		ConcurrentJobs   func(childComplexity int) int
		Duration         func(childComplexity int) int
		Energy           func(childComplexity int) int
		EnergyFootprint  func(childComplexity int) int
		Footprint        func(childComplexity int) int
		ID               func(childComplexity int) int
		JobID            func(childComplexity int) int
		MetaData         func(childComplexity int) int
		MonitoringStatus func(childComplexity int) int
		NumAcc           func(childComplexity int) int
		NumHWThreads     func(childComplexity int) int
		NumNodes         func(childComplexity int) int
		Partition        func(childComplexity int) int
		Project          func(childComplexity int) int
		Resources        func(childComplexity int) int
		SMT              func(childComplexity int) int
		Shared           func(childComplexity int) int
		StartTime        func(childComplexity int) int
		State            func(childComplexity int) int
		SubCluster       func(childComplexity int) int
		Tags             func(childComplexity int) int
		User             func(childComplexity int) int
		UserData         func(childComplexity int) int
		Walltime         func(childComplexity int) int
	}

	JobLink struct {
		ID    func(childComplexity int) int
		JobID func(childComplexity int) int
	}

	JobLinkResultList struct {
		Count     func(childComplexity int) int
		Items     func(childComplexity int) int
		ListQuery func(childComplexity int) int
	}

	JobMetric struct {
		Series           func(childComplexity int) int
		StatisticsSeries func(childComplexity int) int
		Timestep         func(childComplexity int) int
		Unit             func(childComplexity int) int
	}

	JobMetricWithName struct {
		Metric func(childComplexity int) int
		Name   func(childComplexity int) int
		Scope  func(childComplexity int) int
	}

	JobResultList struct {
		Count       func(childComplexity int) int
		HasNextPage func(childComplexity int) int
		Items       func(childComplexity int) int
		Limit       func(childComplexity int) int
		Offset      func(childComplexity int) int
	}

	JobStats struct {
		Cluster         func(childComplexity int) int
		Duration        func(childComplexity int) int
		ID              func(childComplexity int) int
		JobID           func(childComplexity int) int
		NumAccelerators func(childComplexity int) int
		NumHWThreads    func(childComplexity int) int
		NumNodes        func(childComplexity int) int
		StartTime       func(childComplexity int) int
		Stats           func(childComplexity int) int
		SubCluster      func(childComplexity int) int
	}

	JobsStatistics struct {
		HistDuration   func(childComplexity int) int
		HistMetrics    func(childComplexity int) int
		HistNumAccs    func(childComplexity int) int
		HistNumCores   func(childComplexity int) int
		HistNumNodes   func(childComplexity int) int
		ID             func(childComplexity int) int
		Name           func(childComplexity int) int
		RunningJobs    func(childComplexity int) int
		ShortJobs      func(childComplexity int) int
		TotalAccHours  func(childComplexity int) int
		TotalAccs      func(childComplexity int) int
		TotalCoreHours func(childComplexity int) int
		TotalCores     func(childComplexity int) int
		TotalJobs      func(childComplexity int) int
		TotalNodeHours func(childComplexity int) int
		TotalNodes     func(childComplexity int) int
		TotalUsers     func(childComplexity int) int
		TotalWalltime  func(childComplexity int) int
	}

	MetricConfig struct {
		Aggregation   func(childComplexity int) int
		Alert         func(childComplexity int) int
		Caution       func(childComplexity int) int
		LowerIsBetter func(childComplexity int) int
		Name          func(childComplexity int) int
		Normal        func(childComplexity int) int
		Peak          func(childComplexity int) int
		Scope         func(childComplexity int) int
		SubClusters   func(childComplexity int) int
		Timestep      func(childComplexity int) int
		Tooltip       func(childComplexity int) int
		Unit          func(childComplexity int) int
	}

	MetricFootprints struct {
		Data   func(childComplexity int) int
		Metric func(childComplexity int) int
	}

	MetricHistoPoint struct {
		Bin   func(childComplexity int) int
		Count func(childComplexity int) int
		Max   func(childComplexity int) int
		Min   func(childComplexity int) int
	}

	MetricHistoPoints struct {
		Data   func(childComplexity int) int
		Metric func(childComplexity int) int
		Stat   func(childComplexity int) int
		Unit   func(childComplexity int) int
	}

	MetricStatistics struct {
		Avg func(childComplexity int) int
		Max func(childComplexity int) int
		Min func(childComplexity int) int
	}

	MetricValue struct {
		Name  func(childComplexity int) int
		Unit  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	Mutation struct {
		AddTagsToJob        func(childComplexity int, job string, tagIds []string) int
		CreateTag           func(childComplexity int, typeArg string, name string, scope string) int
		DeleteTag           func(childComplexity int, id string) int
		RemoveTagFromList   func(childComplexity int, tagIds []string) int
		RemoveTagsFromJob   func(childComplexity int, job string, tagIds []string) int
		UpdateConfiguration func(childComplexity int, name string, value string) int
	}

	NamedStats struct {
		Data func(childComplexity int) int
		Name func(childComplexity int) int
	}

	NamedStatsWithScope struct {
		Name  func(childComplexity int) int
		Scope func(childComplexity int) int
		Stats func(childComplexity int) int
	}

	Node struct {
		Cluster         func(childComplexity int) int
		CpusAllocated   func(childComplexity int) int
		GpusAllocated   func(childComplexity int) int
		HealthData      func(childComplexity int) int
		HealthState     func(childComplexity int) int
		Hostname        func(childComplexity int) int
		ID              func(childComplexity int) int
		JobsRunning     func(childComplexity int) int
		MemoryAllocated func(childComplexity int) int
		MetaData        func(childComplexity int) int
		SchedulerState  func(childComplexity int) int
		SubCluster      func(childComplexity int) int
	}

	NodeMetrics struct {
		Host         func(childComplexity int) int
		MetricHealth func(childComplexity int) int
		Metrics      func(childComplexity int) int
		NodeState    func(childComplexity int) int
		SubCluster   func(childComplexity int) int
	}

	NodeStateResultList struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	NodeStates struct {
		Count func(childComplexity int) int
		State func(childComplexity int) int
	}

	NodeStatesTimed struct {
		Counts func(childComplexity int) int
		State  func(childComplexity int) int
		Times  func(childComplexity int) int
	}

	NodesResultList struct {
		Count       func(childComplexity int) int
		HasNextPage func(childComplexity int) int
		Items       func(childComplexity int) int
		Limit       func(childComplexity int) int
		Offset      func(childComplexity int) int
		TotalNodes  func(childComplexity int) int
	}

	Query struct {
		AllocatedNodes  func(childComplexity int, cluster string) int
		ClusterMetrics  func(childComplexity int, cluster string, metrics []string, from time.Time, to time.Time) int
		Clusters        func(childComplexity int) int
		GlobalMetrics   func(childComplexity int) int
		Job             func(childComplexity int, id string) int
		JobMetrics      func(childComplexity int, id string, metrics []string, scopes []schema.MetricScope, resolution *int, resampleAlgo *model.ResampleAlgo) int
		JobStats        func(childComplexity int, id string, metrics []string) int
		Jobs            func(childComplexity int, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) int
		JobsFootprints  func(childComplexity int, filter []*model.JobFilter, metrics []string) int
		JobsMetricStats func(childComplexity int, filter []*model.JobFilter, metrics []string) int
		JobsStatistics  func(childComplexity int, filter []*model.JobFilter, metrics []string, page *model.PageRequest, sortBy *model.SortByAggregate, groupBy *model.Aggregate, numDurationBins *string, numMetricBins *int) int
		Node            func(childComplexity int, id string) int
		NodeMetrics     func(childComplexity int, cluster string, nodes []string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time) int
		NodeMetricsList func(childComplexity int, cluster string, subCluster string, stateFilter string, nodeFilter string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time, page *model.PageRequest, resolution *int, resampleAlgo *model.ResampleAlgo) int
		NodeStates      func(childComplexity int, filter []*model.NodeFilter) int
		NodeStatesTimed func(childComplexity int, filter []*model.NodeFilter, typeArg string) int
		Nodes           func(childComplexity int, filter []*model.NodeFilter, order *model.OrderByInput) int
		NodesWithMeta   func(childComplexity int, filter []*model.NodeFilter, order *model.OrderByInput) int
		RooflineHeatmap func(childComplexity int, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) int
		ScopedJobStats  func(childComplexity int, id string, metrics []string, scopes []schema.MetricScope) int
		Tags            func(childComplexity int) int
		User            func(childComplexity int, username string) int
	}

	Resource struct {
		Accelerators  func(childComplexity int) int
		Configuration func(childComplexity int) int
		HWThreads     func(childComplexity int) int
		Hostname      func(childComplexity int) int
	}

	ScopedStats struct {
		Data     func(childComplexity int) int
		Hostname func(childComplexity int) int
		ID       func(childComplexity int) int
	}

	Series struct {
		Data       func(childComplexity int) int
		Hostname   func(childComplexity int) int
		ID         func(childComplexity int) int
		Statistics func(childComplexity int) int
	}

	StatsSeries struct {
		Max    func(childComplexity int) int
		Mean   func(childComplexity int) int
		Median func(childComplexity int) int
		Min    func(childComplexity int) int
	}

	SubCluster struct {
		CoresPerSocket  func(childComplexity int) int
		FlopRateScalar  func(childComplexity int) int
		FlopRateSimd    func(childComplexity int) int
		Footprint       func(childComplexity int) int
		MemoryBandwidth func(childComplexity int) int
		MetricConfig    func(childComplexity int) int
		Name            func(childComplexity int) int
		Nodes           func(childComplexity int) int
		NumberOfNodes   func(childComplexity int) int
		ProcessorType   func(childComplexity int) int
		SocketsPerNode  func(childComplexity int) int
		ThreadsPerCore  func(childComplexity int) int
		Topology        func(childComplexity int) int
	}

	SubClusterConfig struct {
		Alert   func(childComplexity int) int
		Caution func(childComplexity int) int
		Name    func(childComplexity int) int
		Normal  func(childComplexity int) int
		Peak    func(childComplexity int) int
		Remove  func(childComplexity int) int
	}

	Tag struct {
		ID    func(childComplexity int) int
		Name  func(childComplexity int) int
		Scope func(childComplexity int) int
		Type  func(childComplexity int) int
	}

	TimeRangeOutput struct {
		From  func(childComplexity int) int
		Range func(childComplexity int) int
		To    func(childComplexity int) int
	}

	TimeWeights struct {
		AccHours  func(childComplexity int) int
		CoreHours func(childComplexity int) int
		NodeHours func(childComplexity int) int
	}

	Topology struct {
		Accelerators func(childComplexity int) int
		Core         func(childComplexity int) int
		Die          func(childComplexity int) int
		MemoryDomain func(childComplexity int) int
		Node         func(childComplexity int) int
		Socket       func(childComplexity int) int
	}

	Unit struct {
		Base   func(childComplexity int) int
		Prefix func(childComplexity int) int
	}

	User struct {
		Email    func(childComplexity int) int
		Name     func(childComplexity int) int
		Username func(childComplexity int) int
	}
}

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

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

type ClusterResolver interface {
	Partitions(ctx context.Context, obj *schema.Cluster) ([]string, error)
}
type JobResolver interface {
	StartTime(ctx context.Context, obj *schema.Job) (*time.Time, error)

	Tags(ctx context.Context, obj *schema.Job) ([]*schema.Tag, error)

	ConcurrentJobs(ctx context.Context, obj *schema.Job) (*model.JobLinkResultList, error)
	Footprint(ctx context.Context, obj *schema.Job) ([]*model.FootprintValue, error)
	EnergyFootprint(ctx context.Context, obj *schema.Job) ([]*model.EnergyFootprintValue, error)
	MetaData(ctx context.Context, obj *schema.Job) (interface{}, error)
	UserData(ctx context.Context, obj *schema.Job) (*model.User, error)
}
type MetricValueResolver interface {
	Name(ctx context.Context, obj *schema.MetricValue) (*string, error)
}
type MutationResolver interface {
	CreateTag(ctx context.Context, typeArg string, name string, scope string) (*schema.Tag, error)
	DeleteTag(ctx context.Context, id string) (string, error)
	AddTagsToJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error)
	RemoveTagsFromJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error)
	RemoveTagFromList(ctx context.Context, tagIds []string) ([]int, error)
	UpdateConfiguration(ctx context.Context, name string, value string) (*string, error)
}
type NodeResolver interface {
	ID(ctx context.Context, obj *schema.Node) (string, error)

	SchedulerState(ctx context.Context, obj *schema.Node) (schema.SchedulerState, error)
	HealthState(ctx context.Context, obj *schema.Node) (string, error)
	MetaData(ctx context.Context, obj *schema.Node) (interface{}, error)
	HealthData(ctx context.Context, obj *schema.Node) (interface{}, error)
}
type QueryResolver interface {
	Clusters(ctx context.Context) ([]*schema.Cluster, error)
	Tags(ctx context.Context) ([]*schema.Tag, error)
	GlobalMetrics(ctx context.Context) ([]*schema.GlobalMetricListItem, error)
	User(ctx context.Context, username string) (*model.User, error)
	AllocatedNodes(ctx context.Context, cluster string) ([]*model.Count, error)
	Node(ctx context.Context, id string) (*schema.Node, error)
	Nodes(ctx context.Context, filter []*model.NodeFilter, order *model.OrderByInput) (*model.NodeStateResultList, error)
	NodesWithMeta(ctx context.Context, filter []*model.NodeFilter, order *model.OrderByInput) (*model.NodeStateResultList, error)
	NodeStates(ctx context.Context, filter []*model.NodeFilter) ([]*model.NodeStates, error)
	NodeStatesTimed(ctx context.Context, filter []*model.NodeFilter, typeArg string) ([]*model.NodeStatesTimed, error)
	Job(ctx context.Context, id string) (*schema.Job, error)
	JobMetrics(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope, resolution *int, resampleAlgo *model.ResampleAlgo) ([]*model.JobMetricWithName, error)
	JobStats(ctx context.Context, id string, metrics []string) ([]*model.NamedStats, error)
	ScopedJobStats(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope) ([]*model.NamedStatsWithScope, error)
	Jobs(ctx context.Context, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) (*model.JobResultList, error)
	JobsStatistics(ctx context.Context, filter []*model.JobFilter, metrics []string, page *model.PageRequest, sortBy *model.SortByAggregate, groupBy *model.Aggregate, numDurationBins *string, numMetricBins *int) ([]*model.JobsStatistics, error)
	JobsMetricStats(ctx context.Context, filter []*model.JobFilter, metrics []string) ([]*model.JobStats, error)
	JobsFootprints(ctx context.Context, filter []*model.JobFilter, metrics []string) (*model.Footprints, error)
	RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error)
	NodeMetrics(ctx context.Context, cluster string, nodes []string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time) ([]*model.NodeMetrics, error)
	NodeMetricsList(ctx context.Context, cluster string, subCluster string, stateFilter string, nodeFilter string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time, page *model.PageRequest, resolution *int, resampleAlgo *model.ResampleAlgo) (*model.NodesResultList, error)
	ClusterMetrics(ctx context.Context, cluster string, metrics []string, from time.Time, to time.Time) (*model.ClusterMetrics, error)
}
type SubClusterResolver interface {
	NumberOfNodes(ctx context.Context, obj *schema.SubCluster) (int, 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 "Accelerator.id":
		if e.ComplexityRoot.Accelerator.ID == nil {
			break
		}

		return e.ComplexityRoot.Accelerator.ID(childComplexity), true
	case "Accelerator.model":
		if e.ComplexityRoot.Accelerator.Model == nil {
			break
		}

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

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

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

		return e.ComplexityRoot.Cluster.Name(childComplexity), true
	case "Cluster.partitions":
		if e.ComplexityRoot.Cluster.Partitions == nil {
			break
		}

		return e.ComplexityRoot.Cluster.Partitions(childComplexity), true
	case "Cluster.subClusters":
		if e.ComplexityRoot.Cluster.SubClusters == nil {
			break
		}

		return e.ComplexityRoot.Cluster.SubClusters(childComplexity), true

	case "ClusterMetricWithName.data":
		if e.ComplexityRoot.ClusterMetricWithName.Data == nil {
			break
		}

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

		return e.ComplexityRoot.ClusterMetricWithName.Name(childComplexity), true
	case "ClusterMetricWithName.timestep":
		if e.ComplexityRoot.ClusterMetricWithName.Timestep == nil {
			break
		}

		return e.ComplexityRoot.ClusterMetricWithName.Timestep(childComplexity), true
	case "ClusterMetricWithName.unit":
		if e.ComplexityRoot.ClusterMetricWithName.Unit == nil {
			break
		}

		return e.ComplexityRoot.ClusterMetricWithName.Unit(childComplexity), true

	case "ClusterMetrics.metrics":
		if e.ComplexityRoot.ClusterMetrics.Metrics == nil {
			break
		}

		return e.ComplexityRoot.ClusterMetrics.Metrics(childComplexity), true
	case "ClusterMetrics.nodeCount":
		if e.ComplexityRoot.ClusterMetrics.NodeCount == nil {
			break
		}

		return e.ComplexityRoot.ClusterMetrics.NodeCount(childComplexity), true

	case "ClusterSupport.cluster":
		if e.ComplexityRoot.ClusterSupport.Cluster == nil {
			break
		}

		return e.ComplexityRoot.ClusterSupport.Cluster(childComplexity), true
	case "ClusterSupport.subClusters":
		if e.ComplexityRoot.ClusterSupport.SubClusters == nil {
			break
		}

		return e.ComplexityRoot.ClusterSupport.SubClusters(childComplexity), true

	case "Count.count":
		if e.ComplexityRoot.Count.Count == nil {
			break
		}

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

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

	case "EnergyFootprintValue.hardware":
		if e.ComplexityRoot.EnergyFootprintValue.Hardware == nil {
			break
		}

		return e.ComplexityRoot.EnergyFootprintValue.Hardware(childComplexity), true
	case "EnergyFootprintValue.metric":
		if e.ComplexityRoot.EnergyFootprintValue.Metric == nil {
			break
		}

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

		return e.ComplexityRoot.EnergyFootprintValue.Value(childComplexity), true

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

		return e.ComplexityRoot.FootprintValue.Name(childComplexity), true
	case "FootprintValue.stat":
		if e.ComplexityRoot.FootprintValue.Stat == nil {
			break
		}

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

		return e.ComplexityRoot.FootprintValue.Value(childComplexity), true

	case "Footprints.metrics":
		if e.ComplexityRoot.Footprints.Metrics == nil {
			break
		}

		return e.ComplexityRoot.Footprints.Metrics(childComplexity), true
	case "Footprints.timeWeights":
		if e.ComplexityRoot.Footprints.TimeWeights == nil {
			break
		}

		return e.ComplexityRoot.Footprints.TimeWeights(childComplexity), true

	case "GlobalMetricListItem.availability":
		if e.ComplexityRoot.GlobalMetricListItem.Availability == nil {
			break
		}

		return e.ComplexityRoot.GlobalMetricListItem.Availability(childComplexity), true
	case "GlobalMetricListItem.footprint":
		if e.ComplexityRoot.GlobalMetricListItem.Footprint == nil {
			break
		}

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

		return e.ComplexityRoot.GlobalMetricListItem.Name(childComplexity), true
	case "GlobalMetricListItem.scope":
		if e.ComplexityRoot.GlobalMetricListItem.Scope == nil {
			break
		}

		return e.ComplexityRoot.GlobalMetricListItem.Scope(childComplexity), true
	case "GlobalMetricListItem.tooltip":
		if e.ComplexityRoot.GlobalMetricListItem.Tooltip == nil {
			break
		}

		return e.ComplexityRoot.GlobalMetricListItem.Tooltip(childComplexity), true
	case "GlobalMetricListItem.unit":
		if e.ComplexityRoot.GlobalMetricListItem.Unit == nil {
			break
		}

		return e.ComplexityRoot.GlobalMetricListItem.Unit(childComplexity), true

	case "HistoPoint.count":
		if e.ComplexityRoot.HistoPoint.Count == nil {
			break
		}

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

		return e.ComplexityRoot.HistoPoint.Value(childComplexity), true

	case "IntRangeOutput.from":
		if e.ComplexityRoot.IntRangeOutput.From == nil {
			break
		}

		return e.ComplexityRoot.IntRangeOutput.From(childComplexity), true
	case "IntRangeOutput.to":
		if e.ComplexityRoot.IntRangeOutput.To == nil {
			break
		}

		return e.ComplexityRoot.IntRangeOutput.To(childComplexity), true

	case "Job.arrayJobId":
		if e.ComplexityRoot.Job.ArrayJobID == nil {
			break
		}

		return e.ComplexityRoot.Job.ArrayJobID(childComplexity), true
	case "Job.cluster":
		if e.ComplexityRoot.Job.Cluster == nil {
			break
		}

		return e.ComplexityRoot.Job.Cluster(childComplexity), true
	case "Job.concurrentJobs":
		if e.ComplexityRoot.Job.ConcurrentJobs == nil {
			break
		}

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

		return e.ComplexityRoot.Job.Duration(childComplexity), true
	case "Job.energy":
		if e.ComplexityRoot.Job.Energy == nil {
			break
		}

		return e.ComplexityRoot.Job.Energy(childComplexity), true
	case "Job.energyFootprint":
		if e.ComplexityRoot.Job.EnergyFootprint == nil {
			break
		}

		return e.ComplexityRoot.Job.EnergyFootprint(childComplexity), true
	case "Job.footprint":
		if e.ComplexityRoot.Job.Footprint == nil {
			break
		}

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

		return e.ComplexityRoot.Job.ID(childComplexity), true
	case "Job.jobId":
		if e.ComplexityRoot.Job.JobID == nil {
			break
		}

		return e.ComplexityRoot.Job.JobID(childComplexity), true
	case "Job.metaData":
		if e.ComplexityRoot.Job.MetaData == nil {
			break
		}

		return e.ComplexityRoot.Job.MetaData(childComplexity), true
	case "Job.monitoringStatus":
		if e.ComplexityRoot.Job.MonitoringStatus == nil {
			break
		}

		return e.ComplexityRoot.Job.MonitoringStatus(childComplexity), true
	case "Job.numAcc":
		if e.ComplexityRoot.Job.NumAcc == nil {
			break
		}

		return e.ComplexityRoot.Job.NumAcc(childComplexity), true
	case "Job.numHWThreads":
		if e.ComplexityRoot.Job.NumHWThreads == nil {
			break
		}

		return e.ComplexityRoot.Job.NumHWThreads(childComplexity), true
	case "Job.numNodes":
		if e.ComplexityRoot.Job.NumNodes == nil {
			break
		}

		return e.ComplexityRoot.Job.NumNodes(childComplexity), true
	case "Job.partition":
		if e.ComplexityRoot.Job.Partition == nil {
			break
		}

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

		return e.ComplexityRoot.Job.Project(childComplexity), true
	case "Job.resources":
		if e.ComplexityRoot.Job.Resources == nil {
			break
		}

		return e.ComplexityRoot.Job.Resources(childComplexity), true
	case "Job.SMT":
		if e.ComplexityRoot.Job.SMT == nil {
			break
		}

		return e.ComplexityRoot.Job.SMT(childComplexity), true
	case "Job.shared":
		if e.ComplexityRoot.Job.Shared == nil {
			break
		}

		return e.ComplexityRoot.Job.Shared(childComplexity), true
	case "Job.startTime":
		if e.ComplexityRoot.Job.StartTime == nil {
			break
		}

		return e.ComplexityRoot.Job.StartTime(childComplexity), true
	case "Job.state":
		if e.ComplexityRoot.Job.State == nil {
			break
		}

		return e.ComplexityRoot.Job.State(childComplexity), true
	case "Job.subCluster":
		if e.ComplexityRoot.Job.SubCluster == nil {
			break
		}

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

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

		return e.ComplexityRoot.Job.User(childComplexity), true
	case "Job.userData":
		if e.ComplexityRoot.Job.UserData == nil {
			break
		}

		return e.ComplexityRoot.Job.UserData(childComplexity), true
	case "Job.walltime":
		if e.ComplexityRoot.Job.Walltime == nil {
			break
		}

		return e.ComplexityRoot.Job.Walltime(childComplexity), true

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

		return e.ComplexityRoot.JobLink.ID(childComplexity), true
	case "JobLink.jobId":
		if e.ComplexityRoot.JobLink.JobID == nil {
			break
		}

		return e.ComplexityRoot.JobLink.JobID(childComplexity), true

	case "JobLinkResultList.count":
		if e.ComplexityRoot.JobLinkResultList.Count == nil {
			break
		}

		return e.ComplexityRoot.JobLinkResultList.Count(childComplexity), true
	case "JobLinkResultList.items":
		if e.ComplexityRoot.JobLinkResultList.Items == nil {
			break
		}

		return e.ComplexityRoot.JobLinkResultList.Items(childComplexity), true
	case "JobLinkResultList.listQuery":
		if e.ComplexityRoot.JobLinkResultList.ListQuery == nil {
			break
		}

		return e.ComplexityRoot.JobLinkResultList.ListQuery(childComplexity), true

	case "JobMetric.series":
		if e.ComplexityRoot.JobMetric.Series == nil {
			break
		}

		return e.ComplexityRoot.JobMetric.Series(childComplexity), true
	case "JobMetric.statisticsSeries":
		if e.ComplexityRoot.JobMetric.StatisticsSeries == nil {
			break
		}

		return e.ComplexityRoot.JobMetric.StatisticsSeries(childComplexity), true
	case "JobMetric.timestep":
		if e.ComplexityRoot.JobMetric.Timestep == nil {
			break
		}

		return e.ComplexityRoot.JobMetric.Timestep(childComplexity), true
	case "JobMetric.unit":
		if e.ComplexityRoot.JobMetric.Unit == nil {
			break
		}

		return e.ComplexityRoot.JobMetric.Unit(childComplexity), true

	case "JobMetricWithName.metric":
		if e.ComplexityRoot.JobMetricWithName.Metric == nil {
			break
		}

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

		return e.ComplexityRoot.JobMetricWithName.Name(childComplexity), true
	case "JobMetricWithName.scope":
		if e.ComplexityRoot.JobMetricWithName.Scope == nil {
			break
		}

		return e.ComplexityRoot.JobMetricWithName.Scope(childComplexity), true

	case "JobResultList.count":
		if e.ComplexityRoot.JobResultList.Count == nil {
			break
		}

		return e.ComplexityRoot.JobResultList.Count(childComplexity), true
	case "JobResultList.hasNextPage":
		if e.ComplexityRoot.JobResultList.HasNextPage == nil {
			break
		}

		return e.ComplexityRoot.JobResultList.HasNextPage(childComplexity), true
	case "JobResultList.items":
		if e.ComplexityRoot.JobResultList.Items == nil {
			break
		}

		return e.ComplexityRoot.JobResultList.Items(childComplexity), true
	case "JobResultList.limit":
		if e.ComplexityRoot.JobResultList.Limit == nil {
			break
		}

		return e.ComplexityRoot.JobResultList.Limit(childComplexity), true
	case "JobResultList.offset":
		if e.ComplexityRoot.JobResultList.Offset == nil {
			break
		}

		return e.ComplexityRoot.JobResultList.Offset(childComplexity), true

	case "JobStats.cluster":
		if e.ComplexityRoot.JobStats.Cluster == nil {
			break
		}

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

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

		return e.ComplexityRoot.JobStats.ID(childComplexity), true
	case "JobStats.jobId":
		if e.ComplexityRoot.JobStats.JobID == nil {
			break
		}

		return e.ComplexityRoot.JobStats.JobID(childComplexity), true
	case "JobStats.numAccelerators":
		if e.ComplexityRoot.JobStats.NumAccelerators == nil {
			break
		}

		return e.ComplexityRoot.JobStats.NumAccelerators(childComplexity), true
	case "JobStats.numHWThreads":
		if e.ComplexityRoot.JobStats.NumHWThreads == nil {
			break
		}

		return e.ComplexityRoot.JobStats.NumHWThreads(childComplexity), true
	case "JobStats.numNodes":
		if e.ComplexityRoot.JobStats.NumNodes == nil {
			break
		}

		return e.ComplexityRoot.JobStats.NumNodes(childComplexity), true
	case "JobStats.startTime":
		if e.ComplexityRoot.JobStats.StartTime == nil {
			break
		}

		return e.ComplexityRoot.JobStats.StartTime(childComplexity), true
	case "JobStats.stats":
		if e.ComplexityRoot.JobStats.Stats == nil {
			break
		}

		return e.ComplexityRoot.JobStats.Stats(childComplexity), true
	case "JobStats.subCluster":
		if e.ComplexityRoot.JobStats.SubCluster == nil {
			break
		}

		return e.ComplexityRoot.JobStats.SubCluster(childComplexity), true

	case "JobsStatistics.histDuration":
		if e.ComplexityRoot.JobsStatistics.HistDuration == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.HistDuration(childComplexity), true
	case "JobsStatistics.histMetrics":
		if e.ComplexityRoot.JobsStatistics.HistMetrics == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.HistMetrics(childComplexity), true
	case "JobsStatistics.histNumAccs":
		if e.ComplexityRoot.JobsStatistics.HistNumAccs == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.HistNumAccs(childComplexity), true
	case "JobsStatistics.histNumCores":
		if e.ComplexityRoot.JobsStatistics.HistNumCores == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.HistNumCores(childComplexity), true
	case "JobsStatistics.histNumNodes":
		if e.ComplexityRoot.JobsStatistics.HistNumNodes == nil {
			break
		}

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

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

		return e.ComplexityRoot.JobsStatistics.Name(childComplexity), true
	case "JobsStatistics.runningJobs":
		if e.ComplexityRoot.JobsStatistics.RunningJobs == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.RunningJobs(childComplexity), true
	case "JobsStatistics.shortJobs":
		if e.ComplexityRoot.JobsStatistics.ShortJobs == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.ShortJobs(childComplexity), true
	case "JobsStatistics.totalAccHours":
		if e.ComplexityRoot.JobsStatistics.TotalAccHours == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalAccHours(childComplexity), true
	case "JobsStatistics.totalAccs":
		if e.ComplexityRoot.JobsStatistics.TotalAccs == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalAccs(childComplexity), true
	case "JobsStatistics.totalCoreHours":
		if e.ComplexityRoot.JobsStatistics.TotalCoreHours == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalCoreHours(childComplexity), true
	case "JobsStatistics.totalCores":
		if e.ComplexityRoot.JobsStatistics.TotalCores == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalCores(childComplexity), true
	case "JobsStatistics.totalJobs":
		if e.ComplexityRoot.JobsStatistics.TotalJobs == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalJobs(childComplexity), true
	case "JobsStatistics.totalNodeHours":
		if e.ComplexityRoot.JobsStatistics.TotalNodeHours == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalNodeHours(childComplexity), true
	case "JobsStatistics.totalNodes":
		if e.ComplexityRoot.JobsStatistics.TotalNodes == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalNodes(childComplexity), true
	case "JobsStatistics.totalUsers":
		if e.ComplexityRoot.JobsStatistics.TotalUsers == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalUsers(childComplexity), true
	case "JobsStatistics.totalWalltime":
		if e.ComplexityRoot.JobsStatistics.TotalWalltime == nil {
			break
		}

		return e.ComplexityRoot.JobsStatistics.TotalWalltime(childComplexity), true

	case "MetricConfig.aggregation":
		if e.ComplexityRoot.MetricConfig.Aggregation == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Aggregation(childComplexity), true
	case "MetricConfig.alert":
		if e.ComplexityRoot.MetricConfig.Alert == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Alert(childComplexity), true
	case "MetricConfig.caution":
		if e.ComplexityRoot.MetricConfig.Caution == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Caution(childComplexity), true
	case "MetricConfig.lowerIsBetter":
		if e.ComplexityRoot.MetricConfig.LowerIsBetter == nil {
			break
		}

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

		return e.ComplexityRoot.MetricConfig.Name(childComplexity), true
	case "MetricConfig.normal":
		if e.ComplexityRoot.MetricConfig.Normal == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Normal(childComplexity), true
	case "MetricConfig.peak":
		if e.ComplexityRoot.MetricConfig.Peak == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Peak(childComplexity), true
	case "MetricConfig.scope":
		if e.ComplexityRoot.MetricConfig.Scope == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Scope(childComplexity), true
	case "MetricConfig.subClusters":
		if e.ComplexityRoot.MetricConfig.SubClusters == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.SubClusters(childComplexity), true
	case "MetricConfig.timestep":
		if e.ComplexityRoot.MetricConfig.Timestep == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Timestep(childComplexity), true
	case "MetricConfig.tooltip":
		if e.ComplexityRoot.MetricConfig.Tooltip == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Tooltip(childComplexity), true
	case "MetricConfig.unit":
		if e.ComplexityRoot.MetricConfig.Unit == nil {
			break
		}

		return e.ComplexityRoot.MetricConfig.Unit(childComplexity), true

	case "MetricFootprints.data":
		if e.ComplexityRoot.MetricFootprints.Data == nil {
			break
		}

		return e.ComplexityRoot.MetricFootprints.Data(childComplexity), true
	case "MetricFootprints.metric":
		if e.ComplexityRoot.MetricFootprints.Metric == nil {
			break
		}

		return e.ComplexityRoot.MetricFootprints.Metric(childComplexity), true

	case "MetricHistoPoint.bin":
		if e.ComplexityRoot.MetricHistoPoint.Bin == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoint.Bin(childComplexity), true
	case "MetricHistoPoint.count":
		if e.ComplexityRoot.MetricHistoPoint.Count == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoint.Count(childComplexity), true
	case "MetricHistoPoint.max":
		if e.ComplexityRoot.MetricHistoPoint.Max == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoint.Max(childComplexity), true
	case "MetricHistoPoint.min":
		if e.ComplexityRoot.MetricHistoPoint.Min == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoint.Min(childComplexity), true

	case "MetricHistoPoints.data":
		if e.ComplexityRoot.MetricHistoPoints.Data == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoints.Data(childComplexity), true
	case "MetricHistoPoints.metric":
		if e.ComplexityRoot.MetricHistoPoints.Metric == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoints.Metric(childComplexity), true
	case "MetricHistoPoints.stat":
		if e.ComplexityRoot.MetricHistoPoints.Stat == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoints.Stat(childComplexity), true
	case "MetricHistoPoints.unit":
		if e.ComplexityRoot.MetricHistoPoints.Unit == nil {
			break
		}

		return e.ComplexityRoot.MetricHistoPoints.Unit(childComplexity), true

	case "MetricStatistics.avg":
		if e.ComplexityRoot.MetricStatistics.Avg == nil {
			break
		}

		return e.ComplexityRoot.MetricStatistics.Avg(childComplexity), true
	case "MetricStatistics.max":
		if e.ComplexityRoot.MetricStatistics.Max == nil {
			break
		}

		return e.ComplexityRoot.MetricStatistics.Max(childComplexity), true
	case "MetricStatistics.min":
		if e.ComplexityRoot.MetricStatistics.Min == nil {
			break
		}

		return e.ComplexityRoot.MetricStatistics.Min(childComplexity), true

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

		return e.ComplexityRoot.MetricValue.Name(childComplexity), true
	case "MetricValue.unit":
		if e.ComplexityRoot.MetricValue.Unit == nil {
			break
		}

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

		return e.ComplexityRoot.MetricValue.Value(childComplexity), true

	case "Mutation.addTagsToJob":
		if e.ComplexityRoot.Mutation.AddTagsToJob == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.AddTagsToJob(childComplexity, args["job"].(string), args["tagIds"].([]string)), true
	case "Mutation.createTag":
		if e.ComplexityRoot.Mutation.CreateTag == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.CreateTag(childComplexity, args["type"].(string), args["name"].(string), args["scope"].(string)), true
	case "Mutation.deleteTag":
		if e.ComplexityRoot.Mutation.DeleteTag == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.DeleteTag(childComplexity, args["id"].(string)), true
	case "Mutation.removeTagFromList":
		if e.ComplexityRoot.Mutation.RemoveTagFromList == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.RemoveTagFromList(childComplexity, args["tagIds"].([]string)), true
	case "Mutation.removeTagsFromJob":
		if e.ComplexityRoot.Mutation.RemoveTagsFromJob == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.RemoveTagsFromJob(childComplexity, args["job"].(string), args["tagIds"].([]string)), true
	case "Mutation.updateConfiguration":
		if e.ComplexityRoot.Mutation.UpdateConfiguration == nil {
			break
		}

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

		return e.ComplexityRoot.Mutation.UpdateConfiguration(childComplexity, args["name"].(string), args["value"].(string)), true

	case "NamedStats.data":
		if e.ComplexityRoot.NamedStats.Data == nil {
			break
		}

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

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

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

		return e.ComplexityRoot.NamedStatsWithScope.Name(childComplexity), true
	case "NamedStatsWithScope.scope":
		if e.ComplexityRoot.NamedStatsWithScope.Scope == nil {
			break
		}

		return e.ComplexityRoot.NamedStatsWithScope.Scope(childComplexity), true
	case "NamedStatsWithScope.stats":
		if e.ComplexityRoot.NamedStatsWithScope.Stats == nil {
			break
		}

		return e.ComplexityRoot.NamedStatsWithScope.Stats(childComplexity), true

	case "Node.cluster":
		if e.ComplexityRoot.Node.Cluster == nil {
			break
		}

		return e.ComplexityRoot.Node.Cluster(childComplexity), true
	case "Node.cpusAllocated":
		if e.ComplexityRoot.Node.CpusAllocated == nil {
			break
		}

		return e.ComplexityRoot.Node.CpusAllocated(childComplexity), true
	case "Node.gpusAllocated":
		if e.ComplexityRoot.Node.GpusAllocated == nil {
			break
		}

		return e.ComplexityRoot.Node.GpusAllocated(childComplexity), true
	case "Node.healthData":
		if e.ComplexityRoot.Node.HealthData == nil {
			break
		}

		return e.ComplexityRoot.Node.HealthData(childComplexity), true
	case "Node.healthState":
		if e.ComplexityRoot.Node.HealthState == nil {
			break
		}

		return e.ComplexityRoot.Node.HealthState(childComplexity), true
	case "Node.hostname":
		if e.ComplexityRoot.Node.Hostname == nil {
			break
		}

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

		return e.ComplexityRoot.Node.ID(childComplexity), true
	case "Node.jobsRunning":
		if e.ComplexityRoot.Node.JobsRunning == nil {
			break
		}

		return e.ComplexityRoot.Node.JobsRunning(childComplexity), true
	case "Node.memoryAllocated":
		if e.ComplexityRoot.Node.MemoryAllocated == nil {
			break
		}

		return e.ComplexityRoot.Node.MemoryAllocated(childComplexity), true
	case "Node.metaData":
		if e.ComplexityRoot.Node.MetaData == nil {
			break
		}

		return e.ComplexityRoot.Node.MetaData(childComplexity), true
	case "Node.schedulerState":
		if e.ComplexityRoot.Node.SchedulerState == nil {
			break
		}

		return e.ComplexityRoot.Node.SchedulerState(childComplexity), true
	case "Node.subCluster":
		if e.ComplexityRoot.Node.SubCluster == nil {
			break
		}

		return e.ComplexityRoot.Node.SubCluster(childComplexity), true

	case "NodeMetrics.host":
		if e.ComplexityRoot.NodeMetrics.Host == nil {
			break
		}

		return e.ComplexityRoot.NodeMetrics.Host(childComplexity), true
	case "NodeMetrics.metricHealth":
		if e.ComplexityRoot.NodeMetrics.MetricHealth == nil {
			break
		}

		return e.ComplexityRoot.NodeMetrics.MetricHealth(childComplexity), true
	case "NodeMetrics.metrics":
		if e.ComplexityRoot.NodeMetrics.Metrics == nil {
			break
		}

		return e.ComplexityRoot.NodeMetrics.Metrics(childComplexity), true
	case "NodeMetrics.nodeState":
		if e.ComplexityRoot.NodeMetrics.NodeState == nil {
			break
		}

		return e.ComplexityRoot.NodeMetrics.NodeState(childComplexity), true
	case "NodeMetrics.subCluster":
		if e.ComplexityRoot.NodeMetrics.SubCluster == nil {
			break
		}

		return e.ComplexityRoot.NodeMetrics.SubCluster(childComplexity), true

	case "NodeStateResultList.count":
		if e.ComplexityRoot.NodeStateResultList.Count == nil {
			break
		}

		return e.ComplexityRoot.NodeStateResultList.Count(childComplexity), true
	case "NodeStateResultList.items":
		if e.ComplexityRoot.NodeStateResultList.Items == nil {
			break
		}

		return e.ComplexityRoot.NodeStateResultList.Items(childComplexity), true

	case "NodeStates.count":
		if e.ComplexityRoot.NodeStates.Count == nil {
			break
		}

		return e.ComplexityRoot.NodeStates.Count(childComplexity), true
	case "NodeStates.state":
		if e.ComplexityRoot.NodeStates.State == nil {
			break
		}

		return e.ComplexityRoot.NodeStates.State(childComplexity), true

	case "NodeStatesTimed.counts":
		if e.ComplexityRoot.NodeStatesTimed.Counts == nil {
			break
		}

		return e.ComplexityRoot.NodeStatesTimed.Counts(childComplexity), true
	case "NodeStatesTimed.state":
		if e.ComplexityRoot.NodeStatesTimed.State == nil {
			break
		}

		return e.ComplexityRoot.NodeStatesTimed.State(childComplexity), true
	case "NodeStatesTimed.times":
		if e.ComplexityRoot.NodeStatesTimed.Times == nil {
			break
		}

		return e.ComplexityRoot.NodeStatesTimed.Times(childComplexity), true

	case "NodesResultList.count":
		if e.ComplexityRoot.NodesResultList.Count == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.Count(childComplexity), true
	case "NodesResultList.hasNextPage":
		if e.ComplexityRoot.NodesResultList.HasNextPage == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.HasNextPage(childComplexity), true
	case "NodesResultList.items":
		if e.ComplexityRoot.NodesResultList.Items == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.Items(childComplexity), true
	case "NodesResultList.limit":
		if e.ComplexityRoot.NodesResultList.Limit == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.Limit(childComplexity), true
	case "NodesResultList.offset":
		if e.ComplexityRoot.NodesResultList.Offset == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.Offset(childComplexity), true
	case "NodesResultList.totalNodes":
		if e.ComplexityRoot.NodesResultList.TotalNodes == nil {
			break
		}

		return e.ComplexityRoot.NodesResultList.TotalNodes(childComplexity), true

	case "Query.allocatedNodes":
		if e.ComplexityRoot.Query.AllocatedNodes == nil {
			break
		}

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

		return e.ComplexityRoot.Query.AllocatedNodes(childComplexity, args["cluster"].(string)), true
	case "Query.clusterMetrics":
		if e.ComplexityRoot.Query.ClusterMetrics == nil {
			break
		}

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

		return e.ComplexityRoot.Query.ClusterMetrics(childComplexity, args["cluster"].(string), args["metrics"].([]string), args["from"].(time.Time), args["to"].(time.Time)), true
	case "Query.clusters":
		if e.ComplexityRoot.Query.Clusters == nil {
			break
		}

		return e.ComplexityRoot.Query.Clusters(childComplexity), true
	case "Query.globalMetrics":
		if e.ComplexityRoot.Query.GlobalMetrics == nil {
			break
		}

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

	case "Query.job":
		if e.ComplexityRoot.Query.Job == nil {
			break
		}

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

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

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

		return e.ComplexityRoot.Query.JobMetrics(childComplexity, args["id"].(string), args["metrics"].([]string), args["scopes"].([]schema.MetricScope), args["resolution"].(*int), args["resampleAlgo"].(*model.ResampleAlgo)), true
	case "Query.jobStats":
		if e.ComplexityRoot.Query.JobStats == nil {
			break
		}

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

		return e.ComplexityRoot.Query.JobStats(childComplexity, args["id"].(string), args["metrics"].([]string)), true
	case "Query.jobs":
		if e.ComplexityRoot.Query.Jobs == nil {
			break
		}

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

		return e.ComplexityRoot.Query.Jobs(childComplexity, args["filter"].([]*model.JobFilter), args["page"].(*model.PageRequest), args["order"].(*model.OrderByInput)), true
	case "Query.jobsFootprints":
		if e.ComplexityRoot.Query.JobsFootprints == nil {
			break
		}

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

		return e.ComplexityRoot.Query.JobsFootprints(childComplexity, args["filter"].([]*model.JobFilter), args["metrics"].([]string)), true
	case "Query.jobsMetricStats":
		if e.ComplexityRoot.Query.JobsMetricStats == nil {
			break
		}

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

		return e.ComplexityRoot.Query.JobsMetricStats(childComplexity, args["filter"].([]*model.JobFilter), args["metrics"].([]string)), true
	case "Query.jobsStatistics":
		if e.ComplexityRoot.Query.JobsStatistics == nil {
			break
		}

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

		return e.ComplexityRoot.Query.JobsStatistics(childComplexity, args["filter"].([]*model.JobFilter), args["metrics"].([]string), args["page"].(*model.PageRequest), args["sortBy"].(*model.SortByAggregate), args["groupBy"].(*model.Aggregate), args["numDurationBins"].(*string), args["numMetricBins"].(*int)), true
	case "Query.node":
		if e.ComplexityRoot.Query.Node == nil {
			break
		}

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

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

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

		return e.ComplexityRoot.Query.NodeMetrics(childComplexity, args["cluster"].(string), args["nodes"].([]string), args["scopes"].([]schema.MetricScope), args["metrics"].([]string), args["from"].(time.Time), args["to"].(time.Time)), true
	case "Query.nodeMetricsList":
		if e.ComplexityRoot.Query.NodeMetricsList == nil {
			break
		}

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

		return e.ComplexityRoot.Query.NodeMetricsList(childComplexity, args["cluster"].(string), args["subCluster"].(string), args["stateFilter"].(string), args["nodeFilter"].(string), args["scopes"].([]schema.MetricScope), args["metrics"].([]string), args["from"].(time.Time), args["to"].(time.Time), args["page"].(*model.PageRequest), args["resolution"].(*int), args["resampleAlgo"].(*model.ResampleAlgo)), true
	case "Query.nodeStates":
		if e.ComplexityRoot.Query.NodeStates == nil {
			break
		}

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

		return e.ComplexityRoot.Query.NodeStates(childComplexity, args["filter"].([]*model.NodeFilter)), true
	case "Query.nodeStatesTimed":
		if e.ComplexityRoot.Query.NodeStatesTimed == nil {
			break
		}

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

		return e.ComplexityRoot.Query.NodeStatesTimed(childComplexity, args["filter"].([]*model.NodeFilter), args["type"].(string)), true
	case "Query.nodes":
		if e.ComplexityRoot.Query.Nodes == nil {
			break
		}

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

		return e.ComplexityRoot.Query.Nodes(childComplexity, args["filter"].([]*model.NodeFilter), args["order"].(*model.OrderByInput)), true
	case "Query.nodesWithMeta":
		if e.ComplexityRoot.Query.NodesWithMeta == nil {
			break
		}

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

		return e.ComplexityRoot.Query.NodesWithMeta(childComplexity, args["filter"].([]*model.NodeFilter), args["order"].(*model.OrderByInput)), true
	case "Query.rooflineHeatmap":
		if e.ComplexityRoot.Query.RooflineHeatmap == nil {
			break
		}

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

		return e.ComplexityRoot.Query.RooflineHeatmap(childComplexity, args["filter"].([]*model.JobFilter), args["rows"].(int), args["cols"].(int), args["minX"].(float64), args["minY"].(float64), args["maxX"].(float64), args["maxY"].(float64)), true
	case "Query.scopedJobStats":
		if e.ComplexityRoot.Query.ScopedJobStats == nil {
			break
		}

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

		return e.ComplexityRoot.Query.ScopedJobStats(childComplexity, args["id"].(string), args["metrics"].([]string), args["scopes"].([]schema.MetricScope)), true
	case "Query.tags":
		if e.ComplexityRoot.Query.Tags == nil {
			break
		}

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

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

		return e.ComplexityRoot.Query.User(childComplexity, args["username"].(string)), true

	case "Resource.accelerators":
		if e.ComplexityRoot.Resource.Accelerators == nil {
			break
		}

		return e.ComplexityRoot.Resource.Accelerators(childComplexity), true
	case "Resource.configuration":
		if e.ComplexityRoot.Resource.Configuration == nil {
			break
		}

		return e.ComplexityRoot.Resource.Configuration(childComplexity), true
	case "Resource.hwthreads":
		if e.ComplexityRoot.Resource.HWThreads == nil {
			break
		}

		return e.ComplexityRoot.Resource.HWThreads(childComplexity), true
	case "Resource.hostname":
		if e.ComplexityRoot.Resource.Hostname == nil {
			break
		}

		return e.ComplexityRoot.Resource.Hostname(childComplexity), true

	case "ScopedStats.data":
		if e.ComplexityRoot.ScopedStats.Data == nil {
			break
		}

		return e.ComplexityRoot.ScopedStats.Data(childComplexity), true
	case "ScopedStats.hostname":
		if e.ComplexityRoot.ScopedStats.Hostname == nil {
			break
		}

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

		return e.ComplexityRoot.ScopedStats.ID(childComplexity), true

	case "Series.data":
		if e.ComplexityRoot.Series.Data == nil {
			break
		}

		return e.ComplexityRoot.Series.Data(childComplexity), true
	case "Series.hostname":
		if e.ComplexityRoot.Series.Hostname == nil {
			break
		}

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

		return e.ComplexityRoot.Series.ID(childComplexity), true
	case "Series.statistics":
		if e.ComplexityRoot.Series.Statistics == nil {
			break
		}

		return e.ComplexityRoot.Series.Statistics(childComplexity), true

	case "StatsSeries.max":
		if e.ComplexityRoot.StatsSeries.Max == nil {
			break
		}

		return e.ComplexityRoot.StatsSeries.Max(childComplexity), true
	case "StatsSeries.mean":
		if e.ComplexityRoot.StatsSeries.Mean == nil {
			break
		}

		return e.ComplexityRoot.StatsSeries.Mean(childComplexity), true
	case "StatsSeries.median":
		if e.ComplexityRoot.StatsSeries.Median == nil {
			break
		}

		return e.ComplexityRoot.StatsSeries.Median(childComplexity), true
	case "StatsSeries.min":
		if e.ComplexityRoot.StatsSeries.Min == nil {
			break
		}

		return e.ComplexityRoot.StatsSeries.Min(childComplexity), true

	case "SubCluster.coresPerSocket":
		if e.ComplexityRoot.SubCluster.CoresPerSocket == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.CoresPerSocket(childComplexity), true
	case "SubCluster.flopRateScalar":
		if e.ComplexityRoot.SubCluster.FlopRateScalar == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.FlopRateScalar(childComplexity), true
	case "SubCluster.flopRateSimd":
		if e.ComplexityRoot.SubCluster.FlopRateSimd == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.FlopRateSimd(childComplexity), true
	case "SubCluster.footprint":
		if e.ComplexityRoot.SubCluster.Footprint == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.Footprint(childComplexity), true
	case "SubCluster.memoryBandwidth":
		if e.ComplexityRoot.SubCluster.MemoryBandwidth == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.MemoryBandwidth(childComplexity), true
	case "SubCluster.metricConfig":
		if e.ComplexityRoot.SubCluster.MetricConfig == nil {
			break
		}

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

		return e.ComplexityRoot.SubCluster.Name(childComplexity), true
	case "SubCluster.nodes":
		if e.ComplexityRoot.SubCluster.Nodes == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.Nodes(childComplexity), true
	case "SubCluster.numberOfNodes":
		if e.ComplexityRoot.SubCluster.NumberOfNodes == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.NumberOfNodes(childComplexity), true
	case "SubCluster.processorType":
		if e.ComplexityRoot.SubCluster.ProcessorType == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.ProcessorType(childComplexity), true
	case "SubCluster.socketsPerNode":
		if e.ComplexityRoot.SubCluster.SocketsPerNode == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.SocketsPerNode(childComplexity), true
	case "SubCluster.threadsPerCore":
		if e.ComplexityRoot.SubCluster.ThreadsPerCore == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.ThreadsPerCore(childComplexity), true
	case "SubCluster.topology":
		if e.ComplexityRoot.SubCluster.Topology == nil {
			break
		}

		return e.ComplexityRoot.SubCluster.Topology(childComplexity), true

	case "SubClusterConfig.alert":
		if e.ComplexityRoot.SubClusterConfig.Alert == nil {
			break
		}

		return e.ComplexityRoot.SubClusterConfig.Alert(childComplexity), true
	case "SubClusterConfig.caution":
		if e.ComplexityRoot.SubClusterConfig.Caution == nil {
			break
		}

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

		return e.ComplexityRoot.SubClusterConfig.Name(childComplexity), true
	case "SubClusterConfig.normal":
		if e.ComplexityRoot.SubClusterConfig.Normal == nil {
			break
		}

		return e.ComplexityRoot.SubClusterConfig.Normal(childComplexity), true
	case "SubClusterConfig.peak":
		if e.ComplexityRoot.SubClusterConfig.Peak == nil {
			break
		}

		return e.ComplexityRoot.SubClusterConfig.Peak(childComplexity), true
	case "SubClusterConfig.remove":
		if e.ComplexityRoot.SubClusterConfig.Remove == nil {
			break
		}

		return e.ComplexityRoot.SubClusterConfig.Remove(childComplexity), true

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

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

		return e.ComplexityRoot.Tag.Name(childComplexity), true
	case "Tag.scope":
		if e.ComplexityRoot.Tag.Scope == nil {
			break
		}

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

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

	case "TimeRangeOutput.from":
		if e.ComplexityRoot.TimeRangeOutput.From == nil {
			break
		}

		return e.ComplexityRoot.TimeRangeOutput.From(childComplexity), true
	case "TimeRangeOutput.range":
		if e.ComplexityRoot.TimeRangeOutput.Range == nil {
			break
		}

		return e.ComplexityRoot.TimeRangeOutput.Range(childComplexity), true
	case "TimeRangeOutput.to":
		if e.ComplexityRoot.TimeRangeOutput.To == nil {
			break
		}

		return e.ComplexityRoot.TimeRangeOutput.To(childComplexity), true

	case "TimeWeights.accHours":
		if e.ComplexityRoot.TimeWeights.AccHours == nil {
			break
		}

		return e.ComplexityRoot.TimeWeights.AccHours(childComplexity), true
	case "TimeWeights.coreHours":
		if e.ComplexityRoot.TimeWeights.CoreHours == nil {
			break
		}

		return e.ComplexityRoot.TimeWeights.CoreHours(childComplexity), true
	case "TimeWeights.nodeHours":
		if e.ComplexityRoot.TimeWeights.NodeHours == nil {
			break
		}

		return e.ComplexityRoot.TimeWeights.NodeHours(childComplexity), true

	case "Topology.accelerators":
		if e.ComplexityRoot.Topology.Accelerators == nil {
			break
		}

		return e.ComplexityRoot.Topology.Accelerators(childComplexity), true
	case "Topology.core":
		if e.ComplexityRoot.Topology.Core == nil {
			break
		}

		return e.ComplexityRoot.Topology.Core(childComplexity), true
	case "Topology.die":
		if e.ComplexityRoot.Topology.Die == nil {
			break
		}

		return e.ComplexityRoot.Topology.Die(childComplexity), true
	case "Topology.memoryDomain":
		if e.ComplexityRoot.Topology.MemoryDomain == nil {
			break
		}

		return e.ComplexityRoot.Topology.MemoryDomain(childComplexity), true
	case "Topology.node":
		if e.ComplexityRoot.Topology.Node == nil {
			break
		}

		return e.ComplexityRoot.Topology.Node(childComplexity), true
	case "Topology.socket":
		if e.ComplexityRoot.Topology.Socket == nil {
			break
		}

		return e.ComplexityRoot.Topology.Socket(childComplexity), true

	case "Unit.base":
		if e.ComplexityRoot.Unit.Base == nil {
			break
		}

		return e.ComplexityRoot.Unit.Base(childComplexity), true
	case "Unit.prefix":
		if e.ComplexityRoot.Unit.Prefix == nil {
			break
		}

		return e.ComplexityRoot.Unit.Prefix(childComplexity), true

	case "User.email":
		if e.ComplexityRoot.User.Email == nil {
			break
		}

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

		return e.ComplexityRoot.User.Name(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.unmarshalInputFloatRange,
		ec.unmarshalInputIntRange,
		ec.unmarshalInputJobFilter,
		ec.unmarshalInputMetricStatItem,
		ec.unmarshalInputNodeFilter,
		ec.unmarshalInputOrderByInput,
		ec.unmarshalInputPageRequest,
		ec.unmarshalInputStringInput,
		ec.unmarshalInputTimeRange,
	)
	first := true

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

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

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

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

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

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

var sources = []*ast.Source{
	{Name: "../../../api/schema.graphqls", Input: `scalar Time
scalar Any

scalar NullableFloat
scalar MetricScope
scalar JobState
scalar SchedulerState
scalar MonitoringState

type Node {
  id: ID!
  hostname: String!
  cluster: String!
  subCluster: String!
  jobsRunning: Int!
  cpusAllocated: Int
  memoryAllocated: Int
  gpusAllocated: Int
  schedulerState: SchedulerState!
  healthState: MonitoringState!
  metaData: Any
  healthData: Any
}

type NodeStates {
  state: String!
  count: Int!
}

type NodeStatesTimed {
  state: String!
  counts: [Int!]!
  times: [Int!]!
}

type Job {
  id: ID!
  jobId: Int!
  user: String!
  project: String!
  cluster: String!
  subCluster: String!
  startTime: Time!
  duration: Int!
  walltime: Int!
  numNodes: Int!
  numHWThreads: Int!
  numAcc: Int!
  energy: Float!
  SMT: Int!
  shared: String!
  partition: String!
  arrayJobId: Int!
  monitoringStatus: Int!
  state: JobState!
  tags: [Tag!]!
  resources: [Resource!]!
  concurrentJobs: JobLinkResultList
  footprint: [FootprintValue]
  energyFootprint: [EnergyFootprintValue]
  metaData: Any
  userData: User
}

type JobLink {
  id: ID!
  jobId: Int!
}

type Cluster {
  name: String!
  partitions: [String!]! # Slurm partitions
  subClusters: [SubCluster!]! # Hardware partitions/subclusters
}

type SubCluster {
  name: String!
  nodes: String!
  numberOfNodes: Int!
  processorType: String!
  socketsPerNode: Int!
  coresPerSocket: Int!
  threadsPerCore: Int!
  flopRateScalar: MetricValue!
  flopRateSimd: MetricValue!
  memoryBandwidth: MetricValue!
  topology: Topology!
  metricConfig: [MetricConfig!]!
  footprint: [String!]!
}

type FootprintValue {
  name: String!
  stat: String!
  value: Float!
}

type EnergyFootprintValue {
  hardware: String!
  metric: String!
  value: Float!
}

type MetricValue {
  name: String
  unit: Unit!
  value: Float!
}

type Topology {
  node: [Int!]
  socket: [[Int!]!]
  memoryDomain: [[Int!]!]
  die: [[Int!]!]
  core: [[Int!]!]
  accelerators: [Accelerator!]
}

type Accelerator {
  id: String!
  type: String!
  model: String!
}

type SubClusterConfig {
  name: String!
  peak: Float
  normal: Float
  caution: Float
  alert: Float
  remove: Boolean
}

type MetricConfig {
  name: String!
  unit: Unit!
  scope: MetricScope!
  aggregation: String!
  timestep: Int!
  peak: Float!
  normal: Float
  caution: Float!
  alert: Float!
  lowerIsBetter: Boolean
  subClusters: [SubClusterConfig!]!
  tooltip: String
}

type Tag {
  id: ID!
  type: String!
  name: String!
  scope: String!
}

type Resource {
  hostname: String!
  hwthreads: [Int!]
  accelerators: [String!]
  configuration: String
}

type JobMetricWithName {
  name: String!
  scope: MetricScope!
  metric: JobMetric!
}

type ClusterMetricWithName {
  name: String!
  unit: Unit
  timestep: Int!
  data: [NullableFloat!]!
}

type JobMetric {
  unit: Unit
  timestep: Int!
  series: [Series!]
  statisticsSeries: StatsSeries
}

type Series {
  hostname: String!
  id: String
  statistics: MetricStatistics
  data: [NullableFloat!]!
}

type StatsSeries {
  mean: [NullableFloat!]!
  median: [NullableFloat!]!
  min: [NullableFloat!]!
  max: [NullableFloat!]!
}

type NamedStatsWithScope {
  name: String!
  scope: MetricScope!
  stats: [ScopedStats!]!
}

type ScopedStats {
  hostname: String!
  id: String
  data: MetricStatistics!
}

type JobStats {
  id: Int!
  jobId: String!
  startTime: Int!
  duration: Int!
  cluster: String!
  subCluster: String!
  numNodes: Int!
  numHWThreads: Int
  numAccelerators: Int
  stats: [NamedStats!]!
}

type NamedStats {
  name: String!
  data: MetricStatistics!
}

type Unit {
  base: String!
  prefix: String
}

type MetricStatistics {
  avg: Float!
  min: Float!
  max: Float!
}

type MetricFootprints {
  metric: String!
  data: [NullableFloat!]!
}

type Footprints {
  timeWeights: TimeWeights!
  metrics: [MetricFootprints!]!
}

type TimeWeights {
  nodeHours: [NullableFloat!]!
  accHours: [NullableFloat!]!
  coreHours: [NullableFloat!]!
}

enum ResampleAlgo {
  LTTB
  AVERAGE
  SIMPLE
}

enum Aggregate {
  USER
  PROJECT
  CLUSTER
  SUBCLUSTER
}
enum SortByAggregate {
  TOTALWALLTIME
  TOTALJOBS
  TOTALUSERS
  TOTALNODES
  TOTALNODEHOURS
  TOTALCORES
  TOTALCOREHOURS
  TOTALACCS
  TOTALACCHOURS
}

type NodeMetrics {
  host: String!
  nodeState: String!
  metricHealth: String!
  subCluster: String!
  metrics: [JobMetricWithName!]!
}

type ClusterMetrics {
  nodeCount: Int!
  metrics: [ClusterMetricWithName!]!
}

type NodesResultList {
  items: [NodeMetrics!]!
  offset: Int
  limit: Int
  count: Int
  totalNodes: Int
  hasNextPage: Boolean
}

type ClusterSupport {
  cluster: String!
  subClusters: [String!]!
}

type GlobalMetricListItem {
  name: String!
  unit: Unit!
  scope: MetricScope!
  footprint: String
  tooltip: String
  availability: [ClusterSupport!]!
}

type Count {
  name: String!
  count: Int!
}

type User {
  username: String!
  name: String!
  email: String!
}

input MetricStatItem {
  metricName: String!
  range: FloatRange!
}

type Query {
  clusters: [Cluster!]! # List of all clusters
  tags: [Tag!]! # List of all tags
  globalMetrics: [GlobalMetricListItem!]!

  user(username: String!): User
  allocatedNodes(cluster: String!): [Count!]!

  ## Node Queries New
  node(id: ID!): Node
  nodes(filter: [NodeFilter!], order: OrderByInput): NodeStateResultList!
  nodesWithMeta(filter: [NodeFilter!], order: OrderByInput): NodeStateResultList!
  nodeStates(filter: [NodeFilter!]): [NodeStates!]!
  nodeStatesTimed(filter: [NodeFilter!], type: String!): [NodeStatesTimed!]!

  job(id: ID!): Job
  jobMetrics(
    id: ID!
    metrics: [String!]
    scopes: [MetricScope!]
    resolution: Int
    resampleAlgo: ResampleAlgo
  ): [JobMetricWithName!]!

  jobStats(id: ID!, metrics: [String!]): [NamedStats!]!

  scopedJobStats(
    id: ID!
    metrics: [String!]
    scopes: [MetricScope!]
  ): [NamedStatsWithScope!]!

  jobs(
    filter: [JobFilter!]
    page: PageRequest
    order: OrderByInput
  ): JobResultList!

  jobsStatistics(
    filter: [JobFilter!]
    metrics: [String!]
    page: PageRequest
    sortBy: SortByAggregate
    groupBy: Aggregate
    numDurationBins: String
    numMetricBins: Int
  ): [JobsStatistics!]!

  jobsMetricStats(filter: [JobFilter!], metrics: [String!]): [JobStats!]!
  jobsFootprints(filter: [JobFilter!], metrics: [String!]!): Footprints

  rooflineHeatmap(
    filter: [JobFilter!]!
    rows: Int!
    cols: Int!
    minX: Float!
    minY: Float!
    maxX: Float!
    maxY: Float!
  ): [[Float!]!]!

  nodeMetrics(
    cluster: String!
    nodes: [String!]
    scopes: [MetricScope!]
    metrics: [String!]
    from: Time!
    to: Time!
  ): [NodeMetrics!]!

  nodeMetricsList(
    cluster: String!
    subCluster: String!
    stateFilter: String!
    nodeFilter: String!
    scopes: [MetricScope!]
    metrics: [String!]
    from: Time!
    to: Time!
    page: PageRequest
    resolution: Int
    resampleAlgo: ResampleAlgo
  ): NodesResultList!

  clusterMetrics(
    cluster: String!
    metrics: [String!]
    from: Time!
    to: Time!
  ): ClusterMetrics!
}

type Mutation {
  createTag(type: String!, name: String!, scope: String!): Tag!
  deleteTag(id: ID!): ID!
  addTagsToJob(job: ID!, tagIds: [ID!]!): [Tag!]!
  removeTagsFromJob(job: ID!, tagIds: [ID!]!): [Tag!]!
  removeTagFromList(tagIds: [ID!]!): [Int!]!

  updateConfiguration(name: String!, value: String!): String
}

type IntRangeOutput {
  from: Int!
  to: Int!
}
type TimeRangeOutput {
  range: String
  from: Time!
  to: Time!
}

input NodeFilter {
  hostname: StringInput
  cluster: StringInput
  subCluster: StringInput
  schedulerState: SchedulerState
  healthState: MonitoringState
  timeStart: Int
}

input JobFilter {
  tags: [ID!]
  dbId: [ID!]
  jobId: StringInput
  arrayJobId: Int
  user: StringInput
  project: StringInput
  jobName: StringInput
  cluster: StringInput
  subCluster: StringInput
  partition: StringInput
  duration: IntRange
  energy: FloatRange

  numNodes: IntRange
  numAccelerators: IntRange
  numHWThreads: IntRange

  startTime: TimeRange
  state: [JobState!]
  metricStats: [MetricStatItem!]
  shared: String
  schedule: String
  node: StringInput
}

input OrderByInput {
  field: String!
  type: String!
  order: SortDirectionEnum! = ASC
}

enum SortDirectionEnum {
  DESC
  ASC
}

input StringInput {
  eq: String
  neq: String
  contains: String
  startsWith: String
  endsWith: String
  in: [String!]
}

input IntRange {
  from: Int!
  to: Int!
}
input TimeRange {
  range: String
  from: Time
  to: Time
}

input FloatRange {
  from: Float!
  to: Float!
}

type NodeStateResultList {
  items: [Node!]!
  count: Int
}

type JobResultList {
  items: [Job!]!
  offset: Int
  limit: Int
  count: Int
  hasNextPage: Boolean
}

type JobLinkResultList {
  listQuery: String
  items: [JobLink!]!
  count: Int
}

type HistoPoint {
  count: Int!
  value: Int!
}

type MetricHistoPoints {
  metric: String!
  unit: String!
  stat: String
  data: [MetricHistoPoint!]
}

type MetricHistoPoint {
  bin: Int
  count: Int!
  min: Int
  max: Int
}

type JobsStatistics {
  id: ID! # If ` + "`" + `groupBy` + "`" + ` was used, ID of the user/project/cluster/subcluster
  name: String! # if User-Statistics: Given Name of Account (ID) Owner
  totalUsers: Int! # if *not* User-Statistics: Number of active users (based on running jobs)
  totalJobs: Int! # Number of jobs
  runningJobs: Int! # Number of running jobs
  shortJobs: Int! # Number of jobs with a duration of less than config'd ShortRunningJobsDuration
  totalWalltime: Int! # Sum of the duration of all matched jobs in hours
  totalNodes: Int! # Sum of the nodes of all matched jobs
  totalNodeHours: Int! # Sum of the node hours of all matched jobs
  totalCores: Int! # Sum of the cores of all matched jobs
  totalCoreHours: Int! # Sum of the core hours of all matched jobs
  totalAccs: Int! # Sum of the accs of all matched jobs
  totalAccHours: Int! # Sum of the gpu hours of all matched jobs
  histDuration: [HistoPoint!]! # value: hour, count: number of jobs with a rounded duration of value
  histNumNodes: [HistoPoint!]! # value: number of nodes, count: number of jobs with that number of nodes
  histNumCores: [HistoPoint!]! # value: number of cores, count: number of jobs with that number of cores
  histNumAccs: [HistoPoint!]! # value: number of accs, count: number of jobs with that number of accs
  histMetrics: [MetricHistoPoints!]! # metric: metricname, data array of histopoints: value: metric average bin, count: number of jobs with that metric average
}

input PageRequest {
  itemsPerPage: Int!
  page: Int!
}
`, 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_Accelerator(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Accelerator_id(ctx, field)
	case "type":
		return ec.fieldContext_Accelerator_type(ctx, field)
	case "model":
		return ec.fieldContext_Accelerator_model(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Accelerator", field.Name)
}

func (ec *executionContext) childFields_Cluster(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_Cluster_name(ctx, field)
	case "partitions":
		return ec.fieldContext_Cluster_partitions(ctx, field)
	case "subClusters":
		return ec.fieldContext_Cluster_subClusters(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Cluster", field.Name)
}

func (ec *executionContext) childFields_ClusterMetricWithName(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_ClusterMetricWithName_name(ctx, field)
	case "unit":
		return ec.fieldContext_ClusterMetricWithName_unit(ctx, field)
	case "timestep":
		return ec.fieldContext_ClusterMetricWithName_timestep(ctx, field)
	case "data":
		return ec.fieldContext_ClusterMetricWithName_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type ClusterMetricWithName", field.Name)
}

func (ec *executionContext) childFields_ClusterMetrics(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "nodeCount":
		return ec.fieldContext_ClusterMetrics_nodeCount(ctx, field)
	case "metrics":
		return ec.fieldContext_ClusterMetrics_metrics(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type ClusterMetrics", field.Name)
}

func (ec *executionContext) childFields_ClusterSupport(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "cluster":
		return ec.fieldContext_ClusterSupport_cluster(ctx, field)
	case "subClusters":
		return ec.fieldContext_ClusterSupport_subClusters(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type ClusterSupport", field.Name)
}

func (ec *executionContext) childFields_Count(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_Count_name(ctx, field)
	case "count":
		return ec.fieldContext_Count_count(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Count", field.Name)
}

func (ec *executionContext) childFields_EnergyFootprintValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "hardware":
		return ec.fieldContext_EnergyFootprintValue_hardware(ctx, field)
	case "metric":
		return ec.fieldContext_EnergyFootprintValue_metric(ctx, field)
	case "value":
		return ec.fieldContext_EnergyFootprintValue_value(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type EnergyFootprintValue", field.Name)
}

func (ec *executionContext) childFields_FootprintValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_FootprintValue_name(ctx, field)
	case "stat":
		return ec.fieldContext_FootprintValue_stat(ctx, field)
	case "value":
		return ec.fieldContext_FootprintValue_value(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type FootprintValue", field.Name)
}

func (ec *executionContext) childFields_Footprints(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "timeWeights":
		return ec.fieldContext_Footprints_timeWeights(ctx, field)
	case "metrics":
		return ec.fieldContext_Footprints_metrics(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Footprints", field.Name)
}

func (ec *executionContext) childFields_GlobalMetricListItem(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_GlobalMetricListItem_name(ctx, field)
	case "unit":
		return ec.fieldContext_GlobalMetricListItem_unit(ctx, field)
	case "scope":
		return ec.fieldContext_GlobalMetricListItem_scope(ctx, field)
	case "footprint":
		return ec.fieldContext_GlobalMetricListItem_footprint(ctx, field)
	case "tooltip":
		return ec.fieldContext_GlobalMetricListItem_tooltip(ctx, field)
	case "availability":
		return ec.fieldContext_GlobalMetricListItem_availability(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type GlobalMetricListItem", field.Name)
}

func (ec *executionContext) childFields_HistoPoint(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "count":
		return ec.fieldContext_HistoPoint_count(ctx, field)
	case "value":
		return ec.fieldContext_HistoPoint_value(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type HistoPoint", field.Name)
}

func (ec *executionContext) childFields_Job(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Job_id(ctx, field)
	case "jobId":
		return ec.fieldContext_Job_jobId(ctx, field)
	case "user":
		return ec.fieldContext_Job_user(ctx, field)
	case "project":
		return ec.fieldContext_Job_project(ctx, field)
	case "cluster":
		return ec.fieldContext_Job_cluster(ctx, field)
	case "subCluster":
		return ec.fieldContext_Job_subCluster(ctx, field)
	case "startTime":
		return ec.fieldContext_Job_startTime(ctx, field)
	case "duration":
		return ec.fieldContext_Job_duration(ctx, field)
	case "walltime":
		return ec.fieldContext_Job_walltime(ctx, field)
	case "numNodes":
		return ec.fieldContext_Job_numNodes(ctx, field)
	case "numHWThreads":
		return ec.fieldContext_Job_numHWThreads(ctx, field)
	case "numAcc":
		return ec.fieldContext_Job_numAcc(ctx, field)
	case "energy":
		return ec.fieldContext_Job_energy(ctx, field)
	case "SMT":
		return ec.fieldContext_Job_SMT(ctx, field)
	case "shared":
		return ec.fieldContext_Job_shared(ctx, field)
	case "partition":
		return ec.fieldContext_Job_partition(ctx, field)
	case "arrayJobId":
		return ec.fieldContext_Job_arrayJobId(ctx, field)
	case "monitoringStatus":
		return ec.fieldContext_Job_monitoringStatus(ctx, field)
	case "state":
		return ec.fieldContext_Job_state(ctx, field)
	case "tags":
		return ec.fieldContext_Job_tags(ctx, field)
	case "resources":
		return ec.fieldContext_Job_resources(ctx, field)
	case "concurrentJobs":
		return ec.fieldContext_Job_concurrentJobs(ctx, field)
	case "footprint":
		return ec.fieldContext_Job_footprint(ctx, field)
	case "energyFootprint":
		return ec.fieldContext_Job_energyFootprint(ctx, field)
	case "metaData":
		return ec.fieldContext_Job_metaData(ctx, field)
	case "userData":
		return ec.fieldContext_Job_userData(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Job", field.Name)
}

func (ec *executionContext) childFields_JobLink(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_JobLink_id(ctx, field)
	case "jobId":
		return ec.fieldContext_JobLink_jobId(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobLink", field.Name)
}

func (ec *executionContext) childFields_JobLinkResultList(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "listQuery":
		return ec.fieldContext_JobLinkResultList_listQuery(ctx, field)
	case "items":
		return ec.fieldContext_JobLinkResultList_items(ctx, field)
	case "count":
		return ec.fieldContext_JobLinkResultList_count(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobLinkResultList", field.Name)
}

func (ec *executionContext) childFields_JobMetric(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "unit":
		return ec.fieldContext_JobMetric_unit(ctx, field)
	case "timestep":
		return ec.fieldContext_JobMetric_timestep(ctx, field)
	case "series":
		return ec.fieldContext_JobMetric_series(ctx, field)
	case "statisticsSeries":
		return ec.fieldContext_JobMetric_statisticsSeries(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobMetric", field.Name)
}

func (ec *executionContext) childFields_JobMetricWithName(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_JobMetricWithName_name(ctx, field)
	case "scope":
		return ec.fieldContext_JobMetricWithName_scope(ctx, field)
	case "metric":
		return ec.fieldContext_JobMetricWithName_metric(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobMetricWithName", field.Name)
}

func (ec *executionContext) childFields_JobResultList(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "items":
		return ec.fieldContext_JobResultList_items(ctx, field)
	case "offset":
		return ec.fieldContext_JobResultList_offset(ctx, field)
	case "limit":
		return ec.fieldContext_JobResultList_limit(ctx, field)
	case "count":
		return ec.fieldContext_JobResultList_count(ctx, field)
	case "hasNextPage":
		return ec.fieldContext_JobResultList_hasNextPage(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobResultList", field.Name)
}

func (ec *executionContext) childFields_JobStats(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_JobStats_id(ctx, field)
	case "jobId":
		return ec.fieldContext_JobStats_jobId(ctx, field)
	case "startTime":
		return ec.fieldContext_JobStats_startTime(ctx, field)
	case "duration":
		return ec.fieldContext_JobStats_duration(ctx, field)
	case "cluster":
		return ec.fieldContext_JobStats_cluster(ctx, field)
	case "subCluster":
		return ec.fieldContext_JobStats_subCluster(ctx, field)
	case "numNodes":
		return ec.fieldContext_JobStats_numNodes(ctx, field)
	case "numHWThreads":
		return ec.fieldContext_JobStats_numHWThreads(ctx, field)
	case "numAccelerators":
		return ec.fieldContext_JobStats_numAccelerators(ctx, field)
	case "stats":
		return ec.fieldContext_JobStats_stats(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobStats", field.Name)
}

func (ec *executionContext) childFields_JobsStatistics(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_JobsStatistics_id(ctx, field)
	case "name":
		return ec.fieldContext_JobsStatistics_name(ctx, field)
	case "totalUsers":
		return ec.fieldContext_JobsStatistics_totalUsers(ctx, field)
	case "totalJobs":
		return ec.fieldContext_JobsStatistics_totalJobs(ctx, field)
	case "runningJobs":
		return ec.fieldContext_JobsStatistics_runningJobs(ctx, field)
	case "shortJobs":
		return ec.fieldContext_JobsStatistics_shortJobs(ctx, field)
	case "totalWalltime":
		return ec.fieldContext_JobsStatistics_totalWalltime(ctx, field)
	case "totalNodes":
		return ec.fieldContext_JobsStatistics_totalNodes(ctx, field)
	case "totalNodeHours":
		return ec.fieldContext_JobsStatistics_totalNodeHours(ctx, field)
	case "totalCores":
		return ec.fieldContext_JobsStatistics_totalCores(ctx, field)
	case "totalCoreHours":
		return ec.fieldContext_JobsStatistics_totalCoreHours(ctx, field)
	case "totalAccs":
		return ec.fieldContext_JobsStatistics_totalAccs(ctx, field)
	case "totalAccHours":
		return ec.fieldContext_JobsStatistics_totalAccHours(ctx, field)
	case "histDuration":
		return ec.fieldContext_JobsStatistics_histDuration(ctx, field)
	case "histNumNodes":
		return ec.fieldContext_JobsStatistics_histNumNodes(ctx, field)
	case "histNumCores":
		return ec.fieldContext_JobsStatistics_histNumCores(ctx, field)
	case "histNumAccs":
		return ec.fieldContext_JobsStatistics_histNumAccs(ctx, field)
	case "histMetrics":
		return ec.fieldContext_JobsStatistics_histMetrics(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type JobsStatistics", field.Name)
}

func (ec *executionContext) childFields_MetricConfig(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_MetricConfig_name(ctx, field)
	case "unit":
		return ec.fieldContext_MetricConfig_unit(ctx, field)
	case "scope":
		return ec.fieldContext_MetricConfig_scope(ctx, field)
	case "aggregation":
		return ec.fieldContext_MetricConfig_aggregation(ctx, field)
	case "timestep":
		return ec.fieldContext_MetricConfig_timestep(ctx, field)
	case "peak":
		return ec.fieldContext_MetricConfig_peak(ctx, field)
	case "normal":
		return ec.fieldContext_MetricConfig_normal(ctx, field)
	case "caution":
		return ec.fieldContext_MetricConfig_caution(ctx, field)
	case "alert":
		return ec.fieldContext_MetricConfig_alert(ctx, field)
	case "lowerIsBetter":
		return ec.fieldContext_MetricConfig_lowerIsBetter(ctx, field)
	case "subClusters":
		return ec.fieldContext_MetricConfig_subClusters(ctx, field)
	case "tooltip":
		return ec.fieldContext_MetricConfig_tooltip(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricConfig", field.Name)
}

func (ec *executionContext) childFields_MetricFootprints(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "metric":
		return ec.fieldContext_MetricFootprints_metric(ctx, field)
	case "data":
		return ec.fieldContext_MetricFootprints_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricFootprints", field.Name)
}

func (ec *executionContext) childFields_MetricHistoPoint(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "bin":
		return ec.fieldContext_MetricHistoPoint_bin(ctx, field)
	case "count":
		return ec.fieldContext_MetricHistoPoint_count(ctx, field)
	case "min":
		return ec.fieldContext_MetricHistoPoint_min(ctx, field)
	case "max":
		return ec.fieldContext_MetricHistoPoint_max(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricHistoPoint", field.Name)
}

func (ec *executionContext) childFields_MetricHistoPoints(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "metric":
		return ec.fieldContext_MetricHistoPoints_metric(ctx, field)
	case "unit":
		return ec.fieldContext_MetricHistoPoints_unit(ctx, field)
	case "stat":
		return ec.fieldContext_MetricHistoPoints_stat(ctx, field)
	case "data":
		return ec.fieldContext_MetricHistoPoints_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricHistoPoints", field.Name)
}

func (ec *executionContext) childFields_MetricStatistics(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "avg":
		return ec.fieldContext_MetricStatistics_avg(ctx, field)
	case "min":
		return ec.fieldContext_MetricStatistics_min(ctx, field)
	case "max":
		return ec.fieldContext_MetricStatistics_max(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricStatistics", field.Name)
}

func (ec *executionContext) childFields_MetricValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_MetricValue_name(ctx, field)
	case "unit":
		return ec.fieldContext_MetricValue_unit(ctx, field)
	case "value":
		return ec.fieldContext_MetricValue_value(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type MetricValue", field.Name)
}

func (ec *executionContext) childFields_NamedStats(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_NamedStats_name(ctx, field)
	case "data":
		return ec.fieldContext_NamedStats_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NamedStats", field.Name)
}

func (ec *executionContext) childFields_NamedStatsWithScope(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_NamedStatsWithScope_name(ctx, field)
	case "scope":
		return ec.fieldContext_NamedStatsWithScope_scope(ctx, field)
	case "stats":
		return ec.fieldContext_NamedStatsWithScope_stats(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NamedStatsWithScope", field.Name)
}

func (ec *executionContext) childFields_Node(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Node_id(ctx, field)
	case "hostname":
		return ec.fieldContext_Node_hostname(ctx, field)
	case "cluster":
		return ec.fieldContext_Node_cluster(ctx, field)
	case "subCluster":
		return ec.fieldContext_Node_subCluster(ctx, field)
	case "jobsRunning":
		return ec.fieldContext_Node_jobsRunning(ctx, field)
	case "cpusAllocated":
		return ec.fieldContext_Node_cpusAllocated(ctx, field)
	case "memoryAllocated":
		return ec.fieldContext_Node_memoryAllocated(ctx, field)
	case "gpusAllocated":
		return ec.fieldContext_Node_gpusAllocated(ctx, field)
	case "schedulerState":
		return ec.fieldContext_Node_schedulerState(ctx, field)
	case "healthState":
		return ec.fieldContext_Node_healthState(ctx, field)
	case "metaData":
		return ec.fieldContext_Node_metaData(ctx, field)
	case "healthData":
		return ec.fieldContext_Node_healthData(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Node", field.Name)
}

func (ec *executionContext) childFields_NodeMetrics(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "host":
		return ec.fieldContext_NodeMetrics_host(ctx, field)
	case "nodeState":
		return ec.fieldContext_NodeMetrics_nodeState(ctx, field)
	case "metricHealth":
		return ec.fieldContext_NodeMetrics_metricHealth(ctx, field)
	case "subCluster":
		return ec.fieldContext_NodeMetrics_subCluster(ctx, field)
	case "metrics":
		return ec.fieldContext_NodeMetrics_metrics(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NodeMetrics", field.Name)
}

func (ec *executionContext) childFields_NodeStateResultList(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "items":
		return ec.fieldContext_NodeStateResultList_items(ctx, field)
	case "count":
		return ec.fieldContext_NodeStateResultList_count(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NodeStateResultList", field.Name)
}

func (ec *executionContext) childFields_NodeStates(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "state":
		return ec.fieldContext_NodeStates_state(ctx, field)
	case "count":
		return ec.fieldContext_NodeStates_count(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NodeStates", field.Name)
}

func (ec *executionContext) childFields_NodeStatesTimed(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "state":
		return ec.fieldContext_NodeStatesTimed_state(ctx, field)
	case "counts":
		return ec.fieldContext_NodeStatesTimed_counts(ctx, field)
	case "times":
		return ec.fieldContext_NodeStatesTimed_times(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NodeStatesTimed", field.Name)
}

func (ec *executionContext) childFields_NodesResultList(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "items":
		return ec.fieldContext_NodesResultList_items(ctx, field)
	case "offset":
		return ec.fieldContext_NodesResultList_offset(ctx, field)
	case "limit":
		return ec.fieldContext_NodesResultList_limit(ctx, field)
	case "count":
		return ec.fieldContext_NodesResultList_count(ctx, field)
	case "totalNodes":
		return ec.fieldContext_NodesResultList_totalNodes(ctx, field)
	case "hasNextPage":
		return ec.fieldContext_NodesResultList_hasNextPage(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type NodesResultList", field.Name)
}

func (ec *executionContext) childFields_Resource(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "hostname":
		return ec.fieldContext_Resource_hostname(ctx, field)
	case "hwthreads":
		return ec.fieldContext_Resource_hwthreads(ctx, field)
	case "accelerators":
		return ec.fieldContext_Resource_accelerators(ctx, field)
	case "configuration":
		return ec.fieldContext_Resource_configuration(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Resource", field.Name)
}

func (ec *executionContext) childFields_ScopedStats(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "hostname":
		return ec.fieldContext_ScopedStats_hostname(ctx, field)
	case "id":
		return ec.fieldContext_ScopedStats_id(ctx, field)
	case "data":
		return ec.fieldContext_ScopedStats_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type ScopedStats", field.Name)
}

func (ec *executionContext) childFields_Series(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "hostname":
		return ec.fieldContext_Series_hostname(ctx, field)
	case "id":
		return ec.fieldContext_Series_id(ctx, field)
	case "statistics":
		return ec.fieldContext_Series_statistics(ctx, field)
	case "data":
		return ec.fieldContext_Series_data(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Series", field.Name)
}

func (ec *executionContext) childFields_StatsSeries(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "mean":
		return ec.fieldContext_StatsSeries_mean(ctx, field)
	case "median":
		return ec.fieldContext_StatsSeries_median(ctx, field)
	case "min":
		return ec.fieldContext_StatsSeries_min(ctx, field)
	case "max":
		return ec.fieldContext_StatsSeries_max(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type StatsSeries", field.Name)
}

func (ec *executionContext) childFields_SubCluster(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_SubCluster_name(ctx, field)
	case "nodes":
		return ec.fieldContext_SubCluster_nodes(ctx, field)
	case "numberOfNodes":
		return ec.fieldContext_SubCluster_numberOfNodes(ctx, field)
	case "processorType":
		return ec.fieldContext_SubCluster_processorType(ctx, field)
	case "socketsPerNode":
		return ec.fieldContext_SubCluster_socketsPerNode(ctx, field)
	case "coresPerSocket":
		return ec.fieldContext_SubCluster_coresPerSocket(ctx, field)
	case "threadsPerCore":
		return ec.fieldContext_SubCluster_threadsPerCore(ctx, field)
	case "flopRateScalar":
		return ec.fieldContext_SubCluster_flopRateScalar(ctx, field)
	case "flopRateSimd":
		return ec.fieldContext_SubCluster_flopRateSimd(ctx, field)
	case "memoryBandwidth":
		return ec.fieldContext_SubCluster_memoryBandwidth(ctx, field)
	case "topology":
		return ec.fieldContext_SubCluster_topology(ctx, field)
	case "metricConfig":
		return ec.fieldContext_SubCluster_metricConfig(ctx, field)
	case "footprint":
		return ec.fieldContext_SubCluster_footprint(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type SubCluster", field.Name)
}

func (ec *executionContext) childFields_SubClusterConfig(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "name":
		return ec.fieldContext_SubClusterConfig_name(ctx, field)
	case "peak":
		return ec.fieldContext_SubClusterConfig_peak(ctx, field)
	case "normal":
		return ec.fieldContext_SubClusterConfig_normal(ctx, field)
	case "caution":
		return ec.fieldContext_SubClusterConfig_caution(ctx, field)
	case "alert":
		return ec.fieldContext_SubClusterConfig_alert(ctx, field)
	case "remove":
		return ec.fieldContext_SubClusterConfig_remove(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type SubClusterConfig", field.Name)
}

func (ec *executionContext) childFields_Tag(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "id":
		return ec.fieldContext_Tag_id(ctx, field)
	case "type":
		return ec.fieldContext_Tag_type(ctx, field)
	case "name":
		return ec.fieldContext_Tag_name(ctx, field)
	case "scope":
		return ec.fieldContext_Tag_scope(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Tag", field.Name)
}

func (ec *executionContext) childFields_TimeWeights(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "nodeHours":
		return ec.fieldContext_TimeWeights_nodeHours(ctx, field)
	case "accHours":
		return ec.fieldContext_TimeWeights_accHours(ctx, field)
	case "coreHours":
		return ec.fieldContext_TimeWeights_coreHours(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type TimeWeights", field.Name)
}

func (ec *executionContext) childFields_Topology(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "node":
		return ec.fieldContext_Topology_node(ctx, field)
	case "socket":
		return ec.fieldContext_Topology_socket(ctx, field)
	case "memoryDomain":
		return ec.fieldContext_Topology_memoryDomain(ctx, field)
	case "die":
		return ec.fieldContext_Topology_die(ctx, field)
	case "core":
		return ec.fieldContext_Topology_core(ctx, field)
	case "accelerators":
		return ec.fieldContext_Topology_accelerators(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Topology", field.Name)
}

func (ec *executionContext) childFields_Unit(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
	switch field.Name {
	case "base":
		return ec.fieldContext_Unit_base(ctx, field)
	case "prefix":
		return ec.fieldContext_Unit_prefix(ctx, field)
	}
	return nil, fmt.Errorf("no field named %q was found under type Unit", 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 "name":
		return ec.fieldContext_User_name(ctx, field)
	case "email":
		return ec.fieldContext_User_email(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_Mutation_addTagsToJob_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, "job",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["job"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "tagIds",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalNID2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["tagIds"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_createTag_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, "type",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["type"] = 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
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "scope",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["scope"] = arg2
	return args, nil
}

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

func (ec *executionContext) field_Mutation_removeTagFromList_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, "tagIds",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalNID2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["tagIds"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_removeTagsFromJob_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, "job",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["job"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "tagIds",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalNID2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["tagIds"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_updateConfiguration_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
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "value",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["value"] = arg1
	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_allocatedNodes_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, "cluster",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cluster"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_clusterMetrics_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, "cluster",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cluster"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "from",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["from"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "to",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["to"] = arg3
	return args, nil
}

func (ec *executionContext) field_Query_jobMetrics_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "scopes",
		func(ctx context.Context, v any) ([]schema.MetricScope, error) {
			return ec.unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["scopes"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "resolution",
		func(ctx context.Context, v any) (*int, error) {
			return ec.unmarshalOInt2ᚖint(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["resolution"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "resampleAlgo",
		func(ctx context.Context, v any) (*model.ResampleAlgo, error) {
			return ec.unmarshalOResampleAlgo2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐResampleAlgo(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["resampleAlgo"] = arg4
	return args, nil
}

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

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

func (ec *executionContext) field_Query_jobsFootprints_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, "filter",
		func(ctx context.Context, v any) ([]*model.JobFilter, error) {
			return ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalNString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_jobsMetricStats_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, "filter",
		func(ctx context.Context, v any) ([]*model.JobFilter, error) {
			return ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_jobsStatistics_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, "filter",
		func(ctx context.Context, v any) ([]*model.JobFilter, error) {
			return ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "page",
		func(ctx context.Context, v any) (*model.PageRequest, error) {
			return ec.unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐPageRequest(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["page"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "sortBy",
		func(ctx context.Context, v any) (*model.SortByAggregate, error) {
			return ec.unmarshalOSortByAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortByAggregate(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["sortBy"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "groupBy",
		func(ctx context.Context, v any) (*model.Aggregate, error) {
			return ec.unmarshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐAggregate(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["groupBy"] = arg4
	arg5, err := graphql.ProcessArgField(ctx, rawArgs, "numDurationBins",
		func(ctx context.Context, v any) (*string, error) {
			return ec.unmarshalOString2ᚖstring(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["numDurationBins"] = arg5
	arg6, err := graphql.ProcessArgField(ctx, rawArgs, "numMetricBins",
		func(ctx context.Context, v any) (*int, error) {
			return ec.unmarshalOInt2ᚖint(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["numMetricBins"] = arg6
	return args, nil
}

func (ec *executionContext) field_Query_jobs_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, "filter",
		func(ctx context.Context, v any) ([]*model.JobFilter, error) {
			return ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "page",
		func(ctx context.Context, v any) (*model.PageRequest, error) {
			return ec.unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐPageRequest(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["page"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "order",
		func(ctx context.Context, v any) (*model.OrderByInput, error) {
			return ec.unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐOrderByInput(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["order"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_nodeMetricsList_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, "cluster",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cluster"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "subCluster",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["subCluster"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "stateFilter",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["stateFilter"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "nodeFilter",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["nodeFilter"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "scopes",
		func(ctx context.Context, v any) ([]schema.MetricScope, error) {
			return ec.unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["scopes"] = arg4
	arg5, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg5
	arg6, err := graphql.ProcessArgField(ctx, rawArgs, "from",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["from"] = arg6
	arg7, err := graphql.ProcessArgField(ctx, rawArgs, "to",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["to"] = arg7
	arg8, err := graphql.ProcessArgField(ctx, rawArgs, "page",
		func(ctx context.Context, v any) (*model.PageRequest, error) {
			return ec.unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐPageRequest(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["page"] = arg8
	arg9, err := graphql.ProcessArgField(ctx, rawArgs, "resolution",
		func(ctx context.Context, v any) (*int, error) {
			return ec.unmarshalOInt2ᚖint(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["resolution"] = arg9
	arg10, err := graphql.ProcessArgField(ctx, rawArgs, "resampleAlgo",
		func(ctx context.Context, v any) (*model.ResampleAlgo, error) {
			return ec.unmarshalOResampleAlgo2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐResampleAlgo(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["resampleAlgo"] = arg10
	return args, nil
}

func (ec *executionContext) field_Query_nodeMetrics_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, "cluster",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cluster"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "nodes",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["nodes"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "scopes",
		func(ctx context.Context, v any) ([]schema.MetricScope, error) {
			return ec.unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["scopes"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "from",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["from"] = arg4
	arg5, err := graphql.ProcessArgField(ctx, rawArgs, "to",
		func(ctx context.Context, v any) (time.Time, error) {
			return ec.unmarshalNTime2timeᚐTime(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["to"] = arg5
	return args, nil
}

func (ec *executionContext) field_Query_nodeStatesTimed_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, "filter",
		func(ctx context.Context, v any) ([]*model.NodeFilter, error) {
			return ec.unmarshalONodeFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "type",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNString2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["type"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_nodeStates_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, "filter",
		func(ctx context.Context, v any) ([]*model.NodeFilter, error) {
			return ec.unmarshalONodeFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	return args, nil
}

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

func (ec *executionContext) field_Query_nodesWithMeta_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, "filter",
		func(ctx context.Context, v any) ([]*model.NodeFilter, error) {
			return ec.unmarshalONodeFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "order",
		func(ctx context.Context, v any) (*model.OrderByInput, error) {
			return ec.unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐOrderByInput(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["order"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_nodes_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, "filter",
		func(ctx context.Context, v any) ([]*model.NodeFilter, error) {
			return ec.unmarshalONodeFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "order",
		func(ctx context.Context, v any) (*model.OrderByInput, error) {
			return ec.unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐOrderByInput(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["order"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_rooflineHeatmap_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, "filter",
		func(ctx context.Context, v any) ([]*model.JobFilter, error) {
			return ec.unmarshalNJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["filter"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "rows",
		func(ctx context.Context, v any) (int, error) {
			return ec.unmarshalNInt2int(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["rows"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "cols",
		func(ctx context.Context, v any) (int, error) {
			return ec.unmarshalNInt2int(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["cols"] = arg2
	arg3, err := graphql.ProcessArgField(ctx, rawArgs, "minX",
		func(ctx context.Context, v any) (float64, error) {
			return ec.unmarshalNFloat2float64(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["minX"] = arg3
	arg4, err := graphql.ProcessArgField(ctx, rawArgs, "minY",
		func(ctx context.Context, v any) (float64, error) {
			return ec.unmarshalNFloat2float64(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["minY"] = arg4
	arg5, err := graphql.ProcessArgField(ctx, rawArgs, "maxX",
		func(ctx context.Context, v any) (float64, error) {
			return ec.unmarshalNFloat2float64(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["maxX"] = arg5
	arg6, err := graphql.ProcessArgField(ctx, rawArgs, "maxY",
		func(ctx context.Context, v any) (float64, error) {
			return ec.unmarshalNFloat2float64(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["maxY"] = arg6
	return args, nil
}

func (ec *executionContext) field_Query_scopedJobStats_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
	var err error
	args := map[string]any{}
	arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id",
		func(ctx context.Context, v any) (string, error) {
			return ec.unmarshalNID2string(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["id"] = arg0
	arg1, err := graphql.ProcessArgField(ctx, rawArgs, "metrics",
		func(ctx context.Context, v any) ([]string, error) {
			return ec.unmarshalOString2ᚕstringᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["metrics"] = arg1
	arg2, err := graphql.ProcessArgField(ctx, rawArgs, "scopes",
		func(ctx context.Context, v any) ([]schema.MetricScope, error) {
			return ec.unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx, v)
		})
	if err != nil {
		return nil, err
	}
	args["scopes"] = arg2
	return args, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

func (ec *executionContext) _Cluster_subClusters(ctx context.Context, field graphql.CollectedField, obj *schema.Cluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Cluster_subClusters(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.SubClusters, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.SubCluster) graphql.Marshaler {
			return ec.marshalNSubCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Cluster_subClusters(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Cluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_SubCluster(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _ClusterMetricWithName_unit(ctx context.Context, field graphql.CollectedField, obj *model.ClusterMetricWithName) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ClusterMetricWithName_unit(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Unit, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.Unit) graphql.Marshaler {
			return ec.marshalOUnit2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_ClusterMetricWithName_unit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ClusterMetricWithName",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Unit(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _ClusterMetricWithName_data(ctx context.Context, field graphql.CollectedField, obj *model.ClusterMetricWithName) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ClusterMetricWithName_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_ClusterMetricWithName_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("ClusterMetricWithName", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

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

func (ec *executionContext) _ClusterMetrics_metrics(ctx context.Context, field graphql.CollectedField, obj *model.ClusterMetrics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ClusterMetrics_metrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Metrics, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.ClusterMetricWithName) graphql.Marshaler {
			return ec.marshalNClusterMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetricWithNameᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_ClusterMetrics_metrics(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ClusterMetrics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_ClusterMetricWithName(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

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

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

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

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

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

func (ec *executionContext) _Footprints_timeWeights(ctx context.Context, field graphql.CollectedField, obj *model.Footprints) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Footprints_timeWeights(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.TimeWeights, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.TimeWeights) graphql.Marshaler {
			return ec.marshalNTimeWeights2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐTimeWeights(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Footprints_timeWeights(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Footprints",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_TimeWeights(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Footprints_metrics(ctx context.Context, field graphql.CollectedField, obj *model.Footprints) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Footprints_metrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Metrics, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.MetricFootprints) graphql.Marshaler {
			return ec.marshalNMetricFootprints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricFootprintsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Footprints_metrics(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Footprints",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricFootprints(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _GlobalMetricListItem_unit(ctx context.Context, field graphql.CollectedField, obj *schema.GlobalMetricListItem) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_GlobalMetricListItem_unit(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Unit, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.Unit) graphql.Marshaler {
			return ec.marshalNUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_GlobalMetricListItem_unit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "GlobalMetricListItem",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Unit(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _GlobalMetricListItem_scope(ctx context.Context, field graphql.CollectedField, obj *schema.GlobalMetricListItem) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_GlobalMetricListItem_scope(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Scope, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
			return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_GlobalMetricListItem_scope(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("GlobalMetricListItem", field, false, false, errors.New("field of type MetricScope does not have child fields"))
}

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

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

func (ec *executionContext) _GlobalMetricListItem_availability(ctx context.Context, field graphql.CollectedField, obj *schema.GlobalMetricListItem) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_GlobalMetricListItem_availability(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Availability, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.ClusterSupport) graphql.Marshaler {
			return ec.marshalNClusterSupport2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterSupportᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_GlobalMetricListItem_availability(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "GlobalMetricListItem",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_ClusterSupport(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

func (ec *executionContext) _Job_id(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *int64) graphql.Marshaler {
			return ec.marshalNID2ᚖint64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, false, false, errors.New("field of type ID does not have child fields"))
}

func (ec *executionContext) _Job_jobId(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_jobId(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.JobID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int64) graphql.Marshaler {
			return ec.marshalNInt2int64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_jobId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, false, false, errors.New("field of type Int does not have child fields"))
}

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

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

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

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

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

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

func (ec *executionContext) _Job_walltime(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_walltime(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Walltime, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int64) graphql.Marshaler {
			return ec.marshalNInt2int64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_walltime(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, false, false, errors.New("field of type Int does not have child fields"))
}

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

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

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

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

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

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

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

func (ec *executionContext) _Job_arrayJobId(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_arrayJobId(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ArrayJobID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v int64) graphql.Marshaler {
			return ec.marshalNInt2int64(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_arrayJobId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, false, false, errors.New("field of type Int does not have child fields"))
}

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

func (ec *executionContext) _Job_state(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_state(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.State, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.JobState) graphql.Marshaler {
			return ec.marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobState(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_state(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, false, false, errors.New("field of type JobState does not have child fields"))
}

func (ec *executionContext) _Job_tags(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_tags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().Tags(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Tag) graphql.Marshaler {
			return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTagᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tag(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Job_resources(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_resources(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Resources, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Resource) graphql.Marshaler {
			return ec.marshalNResource2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐResourceᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Job_resources(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Resource(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Job_concurrentJobs(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_concurrentJobs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().ConcurrentJobs(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.JobLinkResultList) graphql.Marshaler {
			return ec.marshalOJobLinkResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLinkResultList(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Job_concurrentJobs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_JobLinkResultList(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Job_footprint(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_footprint(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().Footprint(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.FootprintValue) graphql.Marshaler {
			return ec.marshalOFootprintValue2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprintValue(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Job_footprint(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_FootprintValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Job_energyFootprint(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_energyFootprint(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().EnergyFootprint(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.EnergyFootprintValue) graphql.Marshaler {
			return ec.marshalOEnergyFootprintValue2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐEnergyFootprintValue(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Job_energyFootprint(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_EnergyFootprintValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Job_metaData(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_metaData(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().MetaData(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v any) graphql.Marshaler {
			return ec.marshalOAny2interface(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Job_metaData(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Job", field, true, true, errors.New("field of type Any does not have child fields"))
}

func (ec *executionContext) _Job_userData(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Job_userData(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Job().UserData(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.User) graphql.Marshaler {
			return ec.marshalOUser2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐUser(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Job_userData(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Job",
		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) _JobLink_id(ctx context.Context, field graphql.CollectedField, obj *model.JobLink) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobLink_id(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.ID, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobLink_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("JobLink", field, false, false, errors.New("field of type ID does not have child fields"))
}

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

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

func (ec *executionContext) _JobLinkResultList_items(ctx context.Context, field graphql.CollectedField, obj *model.JobLinkResultList) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobLinkResultList_items(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Items, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.JobLink) graphql.Marshaler {
			return ec.marshalNJobLink2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLinkᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobLinkResultList_items(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobLinkResultList",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_JobLink(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _JobMetric_unit(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobMetric_unit(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Unit, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.Unit) graphql.Marshaler {
			return ec.marshalOUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_JobMetric_unit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobMetric",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Unit(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _JobMetric_series(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobMetric_series(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Series, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Series) graphql.Marshaler {
			return ec.marshalOSeries2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSeriesᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_JobMetric_series(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobMetric",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Series(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobMetric_statisticsSeries(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobMetric_statisticsSeries(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.StatisticsSeries, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.StatsSeries) graphql.Marshaler {
			return ec.marshalOStatsSeries2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐStatsSeries(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_JobMetric_statisticsSeries(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobMetric",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_StatsSeries(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _JobMetricWithName_scope(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobMetricWithName_scope(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Scope, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
			return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobMetricWithName_scope(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("JobMetricWithName", field, false, false, errors.New("field of type MetricScope does not have child fields"))
}

func (ec *executionContext) _JobMetricWithName_metric(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobMetricWithName_metric(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Metric, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.JobMetric) graphql.Marshaler {
			return ec.marshalNJobMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobMetric(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobMetricWithName_metric(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobMetricWithName",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_JobMetric(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobResultList_items(ctx context.Context, field graphql.CollectedField, obj *model.JobResultList) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobResultList_items(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Items, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Job) graphql.Marshaler {
			return ec.marshalNJob2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobResultList_items(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobResultList",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Job(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (ec *executionContext) _JobStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.JobStats) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobStats_stats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Stats, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NamedStats) graphql.Marshaler {
			return ec.marshalNNamedStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobStats",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_NamedStats(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (ec *executionContext) _JobsStatistics_histDuration(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobsStatistics_histDuration(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HistDuration, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.HistoPoint) graphql.Marshaler {
			return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPointᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobsStatistics_histDuration(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobsStatistics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_HistoPoint(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobsStatistics_histNumNodes(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobsStatistics_histNumNodes(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HistNumNodes, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.HistoPoint) graphql.Marshaler {
			return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPointᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobsStatistics_histNumNodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobsStatistics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_HistoPoint(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobsStatistics_histNumCores(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobsStatistics_histNumCores(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HistNumCores, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.HistoPoint) graphql.Marshaler {
			return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPointᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobsStatistics_histNumCores(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobsStatistics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_HistoPoint(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobsStatistics_histNumAccs(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobsStatistics_histNumAccs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HistNumAccs, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.HistoPoint) graphql.Marshaler {
			return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPointᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobsStatistics_histNumAccs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobsStatistics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_HistoPoint(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _JobsStatistics_histMetrics(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_JobsStatistics_histMetrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HistMetrics, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.MetricHistoPoints) graphql.Marshaler {
			return ec.marshalNMetricHistoPoints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPointsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_JobsStatistics_histMetrics(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "JobsStatistics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricHistoPoints(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _MetricConfig_unit(ctx context.Context, field graphql.CollectedField, obj *schema.MetricConfig) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricConfig_unit(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Unit, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.Unit) graphql.Marshaler {
			return ec.marshalNUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_MetricConfig_unit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MetricConfig",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Unit(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _MetricConfig_scope(ctx context.Context, field graphql.CollectedField, obj *schema.MetricConfig) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricConfig_scope(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Scope, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
			return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_MetricConfig_scope(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("MetricConfig", field, false, false, errors.New("field of type MetricScope does not have child fields"))
}

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

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

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

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

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

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

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

func (ec *executionContext) _MetricConfig_subClusters(ctx context.Context, field graphql.CollectedField, obj *schema.MetricConfig) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricConfig_subClusters(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.SubClusters, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.SubClusterConfig) graphql.Marshaler {
			return ec.marshalNSubClusterConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterConfigᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_MetricConfig_subClusters(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MetricConfig",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_SubClusterConfig(ctx, field)
		},
	}
	return fc, nil
}

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

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

func (ec *executionContext) _MetricFootprints_data(ctx context.Context, field graphql.CollectedField, obj *model.MetricFootprints) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricFootprints_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_MetricFootprints_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("MetricFootprints", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

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

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

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

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

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

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

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

func (ec *executionContext) _MetricHistoPoints_data(ctx context.Context, field graphql.CollectedField, obj *model.MetricHistoPoints) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricHistoPoints_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.MetricHistoPoint) graphql.Marshaler {
			return ec.marshalOMetricHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPointᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_MetricHistoPoints_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MetricHistoPoints",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricHistoPoint(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

func (ec *executionContext) _MetricValue_unit(ctx context.Context, field graphql.CollectedField, obj *schema.MetricValue) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_MetricValue_unit(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Unit, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.Unit) graphql.Marshaler {
			return ec.marshalNUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_MetricValue_unit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "MetricValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Unit(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _Mutation_createTag(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_createTag(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().CreateTag(ctx, fc.Args["type"].(string), fc.Args["name"].(string), fc.Args["scope"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.Tag) graphql.Marshaler {
			return ec.marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTag(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_createTag(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tag(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_createTag_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_deleteTag(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_deleteTag(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().DeleteTag(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNID2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_deleteTag(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_deleteTag_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_addTagsToJob(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_addTagsToJob(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().AddTagsToJob(ctx, fc.Args["job"].(string), fc.Args["tagIds"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Tag) graphql.Marshaler {
			return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTagᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_addTagsToJob(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tag(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_addTagsToJob_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_removeTagsFromJob(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_removeTagsFromJob(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().RemoveTagsFromJob(ctx, fc.Args["job"].(string), fc.Args["tagIds"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Tag) graphql.Marshaler {
			return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTagᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_removeTagsFromJob(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Tag(ctx, field)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_removeTagsFromJob_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_removeTagFromList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_removeTagFromList(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().RemoveTagFromList(ctx, fc.Args["tagIds"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []int) graphql.Marshaler {
			return ec.marshalNInt2ᚕintᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Mutation_removeTagFromList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Int does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_removeTagFromList_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_updateConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Mutation_updateConfiguration(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Mutation().UpdateConfiguration(ctx, fc.Args["name"].(string), fc.Args["value"].(string))
		},
		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_Mutation_updateConfiguration(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_updateConfiguration_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

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

func (ec *executionContext) _NamedStats_data(ctx context.Context, field graphql.CollectedField, obj *model.NamedStats) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NamedStats_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.MetricStatistics) graphql.Marshaler {
			return ec.marshalNMetricStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricStatistics(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NamedStats_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "NamedStats",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricStatistics(ctx, field)
		},
	}
	return fc, nil
}

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

func (ec *executionContext) _NamedStatsWithScope_scope(ctx context.Context, field graphql.CollectedField, obj *model.NamedStatsWithScope) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NamedStatsWithScope_scope(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Scope, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
			return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NamedStatsWithScope_scope(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("NamedStatsWithScope", field, false, false, errors.New("field of type MetricScope does not have child fields"))
}

func (ec *executionContext) _NamedStatsWithScope_stats(ctx context.Context, field graphql.CollectedField, obj *model.NamedStatsWithScope) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NamedStatsWithScope_stats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Stats, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.ScopedStats) graphql.Marshaler {
			return ec.marshalNScopedStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐScopedStatsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NamedStatsWithScope_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "NamedStatsWithScope",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_ScopedStats(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

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

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

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

func (ec *executionContext) _Node_schedulerState(ctx context.Context, field graphql.CollectedField, obj *schema.Node) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Node_schedulerState(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Node().SchedulerState(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.SchedulerState) graphql.Marshaler {
			return ec.marshalNSchedulerState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Node_schedulerState(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Node", field, true, true, errors.New("field of type SchedulerState does not have child fields"))
}

func (ec *executionContext) _Node_healthState(ctx context.Context, field graphql.CollectedField, obj *schema.Node) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Node_healthState(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Node().HealthState(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
			return ec.marshalNMonitoringState2string(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Node_healthState(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Node", field, true, true, errors.New("field of type MonitoringState does not have child fields"))
}

func (ec *executionContext) _Node_metaData(ctx context.Context, field graphql.CollectedField, obj *schema.Node) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Node_metaData(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Node().MetaData(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v any) graphql.Marshaler {
			return ec.marshalOAny2interface(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Node_metaData(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Node", field, true, true, errors.New("field of type Any does not have child fields"))
}

func (ec *executionContext) _Node_healthData(ctx context.Context, field graphql.CollectedField, obj *schema.Node) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Node_healthData(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Node().HealthData(ctx, obj)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v any) graphql.Marshaler {
			return ec.marshalOAny2interface(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Node_healthData(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Node", field, true, true, errors.New("field of type Any does not have child fields"))
}

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

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

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

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

func (ec *executionContext) _NodeMetrics_metrics(ctx context.Context, field graphql.CollectedField, obj *model.NodeMetrics) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NodeMetrics_metrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Metrics, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.JobMetricWithName) graphql.Marshaler {
			return ec.marshalNJobMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobMetricWithNameᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NodeMetrics_metrics(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "NodeMetrics",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_JobMetricWithName(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _NodeStateResultList_items(ctx context.Context, field graphql.CollectedField, obj *model.NodeStateResultList) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NodeStateResultList_items(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Items, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Node) graphql.Marshaler {
			return ec.marshalNNode2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNodeᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NodeStateResultList_items(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "NodeStateResultList",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Node(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

func (ec *executionContext) _NodeStatesTimed_counts(ctx context.Context, field graphql.CollectedField, obj *model.NodeStatesTimed) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NodeStatesTimed_counts(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Counts, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []int) graphql.Marshaler {
			return ec.marshalNInt2ᚕintᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NodeStatesTimed_counts(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("NodeStatesTimed", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _NodeStatesTimed_times(ctx context.Context, field graphql.CollectedField, obj *model.NodeStatesTimed) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NodeStatesTimed_times(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Times, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []int) graphql.Marshaler {
			return ec.marshalNInt2ᚕintᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NodeStatesTimed_times(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("NodeStatesTimed", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _NodesResultList_items(ctx context.Context, field graphql.CollectedField, obj *model.NodesResultList) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_NodesResultList_items(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Items, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NodeMetrics) graphql.Marshaler {
			return ec.marshalNNodeMetrics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeMetricsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_NodesResultList_items(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "NodesResultList",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_NodeMetrics(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

func (ec *executionContext) _Query_clusters(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_clusters(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Clusters(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Cluster) graphql.Marshaler {
			return ec.marshalNCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_clusters(_ 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_Cluster(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_tags(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Query_tags(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().Tags(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Tag) graphql.Marshaler {
			return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTagᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_tags(_ 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_Tag(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_globalMetrics(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_globalMetrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return ec.Resolvers.Query().GlobalMetrics(ctx)
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.GlobalMetricListItem) graphql.Marshaler {
			return ec.marshalNGlobalMetricListItem2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐGlobalMetricListItemᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_globalMetrics(_ 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_GlobalMetricListItem(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_user(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_user(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().User(ctx, fc.Args["username"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.User) graphql.Marshaler {
			return ec.marshalOUser2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐUser(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_user(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_User(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_user_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_allocatedNodes(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_allocatedNodes(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().AllocatedNodes(ctx, fc.Args["cluster"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.Count) graphql.Marshaler {
			return ec.marshalNCount2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐCountᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_allocatedNodes(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_Count(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_allocatedNodes_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_node(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_node(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Node(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.Node) graphql.Marshaler {
			return ec.marshalONode2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNode(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_node(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_Node(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_node_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodes(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_nodes(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Nodes(ctx, fc.Args["filter"].([]*model.NodeFilter), fc.Args["order"].(*model.OrderByInput))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.NodeStateResultList) graphql.Marshaler {
			return ec.marshalNNodeStateResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStateResultList(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodes(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_NodeStateResultList(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_nodes_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodesWithMeta(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_nodesWithMeta(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NodesWithMeta(ctx, fc.Args["filter"].([]*model.NodeFilter), fc.Args["order"].(*model.OrderByInput))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.NodeStateResultList) graphql.Marshaler {
			return ec.marshalNNodeStateResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStateResultList(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodesWithMeta(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_NodeStateResultList(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_nodesWithMeta_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodeStates(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_nodeStates(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NodeStates(ctx, fc.Args["filter"].([]*model.NodeFilter))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NodeStates) graphql.Marshaler {
			return ec.marshalNNodeStates2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodeStates(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_NodeStates(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_nodeStates_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodeStatesTimed(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_nodeStatesTimed(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NodeStatesTimed(ctx, fc.Args["filter"].([]*model.NodeFilter), fc.Args["type"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NodeStatesTimed) graphql.Marshaler {
			return ec.marshalNNodeStatesTimed2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesTimedᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodeStatesTimed(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_NodeStatesTimed(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_nodeStatesTimed_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_job(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_job(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Job(ctx, fc.Args["id"].(string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.Job) graphql.Marshaler {
			return ec.marshalOJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJob(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_job(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_Job(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_job_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobMetrics(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_jobMetrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().JobMetrics(ctx, fc.Args["id"].(string), fc.Args["metrics"].([]string), fc.Args["scopes"].([]schema.MetricScope), fc.Args["resolution"].(*int), fc.Args["resampleAlgo"].(*model.ResampleAlgo))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.JobMetricWithName) graphql.Marshaler {
			return ec.marshalNJobMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobMetricWithNameᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_jobMetrics(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_JobMetricWithName(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_jobMetrics_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobStats(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_jobStats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().JobStats(ctx, fc.Args["id"].(string), fc.Args["metrics"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NamedStats) graphql.Marshaler {
			return ec.marshalNNamedStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_jobStats(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_NamedStats(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_jobStats_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_scopedJobStats(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_scopedJobStats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().ScopedJobStats(ctx, fc.Args["id"].(string), fc.Args["metrics"].([]string), fc.Args["scopes"].([]schema.MetricScope))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NamedStatsWithScope) graphql.Marshaler {
			return ec.marshalNNamedStatsWithScope2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsWithScopeᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_scopedJobStats(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_NamedStatsWithScope(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_scopedJobStats_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobs(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_jobs(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().Jobs(ctx, fc.Args["filter"].([]*model.JobFilter), fc.Args["page"].(*model.PageRequest), fc.Args["order"].(*model.OrderByInput))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.JobResultList) graphql.Marshaler {
			return ec.marshalNJobResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobResultList(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_jobs(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_JobResultList(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_jobs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobsStatistics(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_jobsStatistics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().JobsStatistics(ctx, fc.Args["filter"].([]*model.JobFilter), fc.Args["metrics"].([]string), fc.Args["page"].(*model.PageRequest), fc.Args["sortBy"].(*model.SortByAggregate), fc.Args["groupBy"].(*model.Aggregate), fc.Args["numDurationBins"].(*string), fc.Args["numMetricBins"].(*int))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.JobsStatistics) graphql.Marshaler {
			return ec.marshalNJobsStatistics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobsStatisticsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_jobsStatistics(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_JobsStatistics(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_jobsStatistics_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobsMetricStats(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_jobsMetricStats(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().JobsMetricStats(ctx, fc.Args["filter"].([]*model.JobFilter), fc.Args["metrics"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.JobStats) graphql.Marshaler {
			return ec.marshalNJobStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobStatsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_jobsMetricStats(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_JobStats(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_jobsMetricStats_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_jobsFootprints(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_jobsFootprints(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().JobsFootprints(ctx, fc.Args["filter"].([]*model.JobFilter), fc.Args["metrics"].([]string))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.Footprints) graphql.Marshaler {
			return ec.marshalOFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprints(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Query_jobsFootprints(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_Footprints(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_jobsFootprints_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_rooflineHeatmap(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_rooflineHeatmap(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().RooflineHeatmap(ctx, fc.Args["filter"].([]*model.JobFilter), fc.Args["rows"].(int), fc.Args["cols"].(int), fc.Args["minX"].(float64), fc.Args["minY"].(float64), fc.Args["maxX"].(float64), fc.Args["maxY"].(float64))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v [][]float64) graphql.Marshaler {
			return ec.marshalNFloat2ᚕᚕfloat64ᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_rooflineHeatmap(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 nil, errors.New("field of type Float does not have child fields")
		},
	}
	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_rooflineHeatmap_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodeMetrics(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_nodeMetrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NodeMetrics(ctx, fc.Args["cluster"].(string), fc.Args["nodes"].([]string), fc.Args["scopes"].([]schema.MetricScope), fc.Args["metrics"].([]string), fc.Args["from"].(time.Time), fc.Args["to"].(time.Time))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*model.NodeMetrics) graphql.Marshaler {
			return ec.marshalNNodeMetrics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeMetricsᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodeMetrics(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_NodeMetrics(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_nodeMetrics_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_nodeMetricsList(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_nodeMetricsList(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().NodeMetricsList(ctx, fc.Args["cluster"].(string), fc.Args["subCluster"].(string), fc.Args["stateFilter"].(string), fc.Args["nodeFilter"].(string), fc.Args["scopes"].([]schema.MetricScope), fc.Args["metrics"].([]string), fc.Args["from"].(time.Time), fc.Args["to"].(time.Time), fc.Args["page"].(*model.PageRequest), fc.Args["resolution"].(*int), fc.Args["resampleAlgo"].(*model.ResampleAlgo))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.NodesResultList) graphql.Marshaler {
			return ec.marshalNNodesResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodesResultList(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_nodeMetricsList(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_NodesResultList(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_nodeMetricsList_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_clusterMetrics(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_clusterMetrics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			fc := graphql.GetFieldContext(ctx)
			return ec.Resolvers.Query().ClusterMetrics(ctx, fc.Args["cluster"].(string), fc.Args["metrics"].([]string), fc.Args["from"].(time.Time), fc.Args["to"].(time.Time))
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *model.ClusterMetrics) graphql.Marshaler {
			return ec.marshalNClusterMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetrics(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Query_clusterMetrics(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_ClusterMetrics(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_clusterMetrics_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) _Resource_hostname(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Resource_hostname(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Hostname, 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_Resource_hostname(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Resource", field, false, false, errors.New("field of type String does not have child fields"))
}

func (ec *executionContext) _Resource_hwthreads(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Resource_hwthreads(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.HWThreads, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []int) graphql.Marshaler {
			return ec.marshalOInt2ᚕintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Resource_hwthreads(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Resource", field, false, false, errors.New("field of type Int does not have child fields"))
}

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

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

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

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

func (ec *executionContext) _ScopedStats_data(ctx context.Context, field graphql.CollectedField, obj *model.ScopedStats) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_ScopedStats_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v *schema.MetricStatistics) graphql.Marshaler {
			return ec.marshalNMetricStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricStatistics(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_ScopedStats_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ScopedStats",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricStatistics(ctx, field)
		},
	}
	return fc, nil
}

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

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

func (ec *executionContext) _Series_statistics(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Series_statistics(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Statistics, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricStatistics) graphql.Marshaler {
			return ec.marshalOMetricStatistics2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricStatistics(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Series_statistics(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Series",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricStatistics(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Series_data(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Series_data(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Data, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_Series_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Series", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _StatsSeries_mean(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_StatsSeries_mean(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Mean, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_StatsSeries_mean(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("StatsSeries", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _StatsSeries_median(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_StatsSeries_median(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Median, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_StatsSeries_median(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("StatsSeries", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _StatsSeries_min(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_StatsSeries_min(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Min, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_StatsSeries_min(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("StatsSeries", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _StatsSeries_max(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_StatsSeries_max(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Max, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_StatsSeries_max(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("StatsSeries", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

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

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

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

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

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

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

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

func (ec *executionContext) _SubCluster_flopRateScalar(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_SubCluster_flopRateScalar(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.FlopRateScalar, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricValue) graphql.Marshaler {
			return ec.marshalNMetricValue2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricValue(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_SubCluster_flopRateScalar(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SubCluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SubCluster_flopRateSimd(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_SubCluster_flopRateSimd(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.FlopRateSimd, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricValue) graphql.Marshaler {
			return ec.marshalNMetricValue2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricValue(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_SubCluster_flopRateSimd(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SubCluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SubCluster_memoryBandwidth(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_SubCluster_memoryBandwidth(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.MemoryBandwidth, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.MetricValue) graphql.Marshaler {
			return ec.marshalNMetricValue2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricValue(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_SubCluster_memoryBandwidth(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SubCluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricValue(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SubCluster_topology(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_SubCluster_topology(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Topology, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v schema.Topology) graphql.Marshaler {
			return ec.marshalNTopology2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTopology(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_SubCluster_topology(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SubCluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Topology(ctx, field)
		},
	}
	return fc, nil
}

func (ec *executionContext) _SubCluster_metricConfig(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_SubCluster_metricConfig(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.MetricConfig, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.MetricConfig) graphql.Marshaler {
			return ec.marshalNMetricConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricConfigᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_SubCluster_metricConfig(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "SubCluster",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_MetricConfig(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (ec *executionContext) _TimeWeights_nodeHours(ctx context.Context, field graphql.CollectedField, obj *model.TimeWeights) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TimeWeights_nodeHours(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.NodeHours, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TimeWeights_nodeHours(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TimeWeights", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _TimeWeights_accHours(ctx context.Context, field graphql.CollectedField, obj *model.TimeWeights) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TimeWeights_accHours(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.AccHours, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TimeWeights_accHours(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TimeWeights", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _TimeWeights_coreHours(ctx context.Context, field graphql.CollectedField, obj *model.TimeWeights) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_TimeWeights_coreHours(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.CoreHours, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []schema.Float) graphql.Marshaler {
			return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx, selections, v)
		},
		true,
		true,
	)
}
func (ec *executionContext) fieldContext_TimeWeights_coreHours(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("TimeWeights", field, false, false, errors.New("field of type NullableFloat does not have child fields"))
}

func (ec *executionContext) _Topology_node(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_node(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Node, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []int) graphql.Marshaler {
			return ec.marshalOInt2ᚕintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Topology", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Topology_socket(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_socket(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Socket, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v [][]int) graphql.Marshaler {
			return ec.marshalOInt2ᚕᚕintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_socket(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Topology", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Topology_memoryDomain(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_memoryDomain(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.MemoryDomain, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v [][]int) graphql.Marshaler {
			return ec.marshalOInt2ᚕᚕintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_memoryDomain(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Topology", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Topology_die(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_die(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Die, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v [][]*int) graphql.Marshaler {
			return ec.marshalOInt2ᚕᚕᚖintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_die(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Topology", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Topology_core(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_core(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Core, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v [][]int) graphql.Marshaler {
			return ec.marshalOInt2ᚕᚕintᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_core(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	return graphql.NewScalarFieldContext("Topology", field, false, false, errors.New("field of type Int does not have child fields"))
}

func (ec *executionContext) _Topology_accelerators(ctx context.Context, field graphql.CollectedField, obj *schema.Topology) (ret graphql.Marshaler) {
	return graphql.ResolveField(
		ctx,
		ec.OperationContext,
		field,
		func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.fieldContext_Topology_accelerators(ctx, field)
		},
		func(ctx context.Context) (any, error) {
			return obj.Accelerators, nil
		},
		nil,
		func(ctx context.Context, selections ast.SelectionSet, v []*schema.Accelerator) graphql.Marshaler {
			return ec.marshalOAccelerator2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐAcceleratorᚄ(ctx, selections, v)
		},
		true,
		false,
	)
}
func (ec *executionContext) fieldContext_Topology_accelerators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Topology",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return ec.childFields_Accelerator(ctx, field)
		},
	}
	return fc, nil
}

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

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

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

func (ec *executionContext) _User_email(ctx context.Context, field graphql.CollectedField, obj *model.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_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_User_email(_ 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) unmarshalInputFloatRange(ctx context.Context, obj any) (model.FloatRange, error) {
	var it model.FloatRange
	if obj == nil {
		return it, nil
	}

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

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

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

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

	fieldsInOrder := [...]string{"from", "to"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "from":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.From = data
		case "to":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.To = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"tags", "dbId", "jobId", "arrayJobId", "user", "project", "jobName", "cluster", "subCluster", "partition", "duration", "energy", "numNodes", "numAccelerators", "numHWThreads", "startTime", "state", "metricStats", "shared", "schedule", "node"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "tags":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags"))
			data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Tags = data
		case "dbId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dbId"))
			data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.DbID = data
		case "jobId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("jobId"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.JobID = data
		case "arrayJobId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arrayJobId"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.ArrayJobID = data
		case "user":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.User = data
		case "project":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("project"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Project = data
		case "jobName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("jobName"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.JobName = data
		case "cluster":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cluster"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Cluster = data
		case "subCluster":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subCluster"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.SubCluster = data
		case "partition":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("partition"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Partition = data
		case "duration":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("duration"))
			data, err := ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐIntRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.Duration = data
		case "energy":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("energy"))
			data, err := ec.unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFloatRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.Energy = data
		case "numNodes":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("numNodes"))
			data, err := ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐIntRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.NumNodes = data
		case "numAccelerators":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("numAccelerators"))
			data, err := ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐIntRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.NumAccelerators = data
		case "numHWThreads":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("numHWThreads"))
			data, err := ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐIntRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.NumHWThreads = data
		case "startTime":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("startTime"))
			data, err := ec.unmarshalOTimeRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐTimeRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.StartTime = data
		case "state":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state"))
			data, err := ec.unmarshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobStateᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.State = data
		case "metricStats":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metricStats"))
			data, err := ec.unmarshalOMetricStatItem2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricStatItemᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.MetricStats = data
		case "shared":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("shared"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Shared = data
		case "schedule":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("schedule"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Schedule = data
		case "node":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("node"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Node = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"metricName", "range"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "metricName":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metricName"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.MetricName = data
		case "range":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("range"))
			data, err := ec.unmarshalNFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFloatRange(ctx, v)
			if err != nil {
				return it, err
			}
			it.Range = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"hostname", "cluster", "subCluster", "schedulerState", "healthState", "timeStart"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "hostname":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hostname"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Hostname = data
		case "cluster":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cluster"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.Cluster = data
		case "subCluster":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subCluster"))
			data, err := ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx, v)
			if err != nil {
				return it, err
			}
			it.SubCluster = data
		case "schedulerState":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("schedulerState"))
			data, err := ec.unmarshalOSchedulerState2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx, v)
			if err != nil {
				return it, err
			}
			it.SchedulerState = data
		case "healthState":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("healthState"))
			data, err := ec.unmarshalOMonitoringState2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.HealthState = data
		case "timeStart":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("timeStart"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.TimeStart = data
		}
	}
	return it, nil
}

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

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

	if _, present := asMap["order"]; !present {
		asMap["order"] = "ASC"
	}

	fieldsInOrder := [...]string{"field", "type", "order"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "field":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		case "type":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Type = data
		case "order":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("order"))
			data, err := ec.unmarshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortDirectionEnum(ctx, v)
			if err != nil {
				return it, err
			}
			it.Order = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"itemsPerPage", "page"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "itemsPerPage":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("itemsPerPage"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.ItemsPerPage = data
		case "page":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("page"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.Page = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"eq", "neq", "contains", "startsWith", "endsWith", "in"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "eq":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eq"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Eq = data
		case "neq":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("neq"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Neq = data
		case "contains":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("contains"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Contains = data
		case "startsWith":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("startsWith"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.StartsWith = data
		case "endsWith":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("endsWith"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.EndsWith = data
		case "in":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.In = data
		}
	}
	return it, nil
}

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

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

	fieldsInOrder := [...]string{"range", "from", "to"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "range":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("range"))
			data, err := ec.unmarshalOString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Range = data
		case "from":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
			data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.From = data
		case "to":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
			data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
			it.To = data
		}
	}
	return it, nil
}

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

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

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

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

var acceleratorImplementors = []string{"Accelerator"}

func (ec *executionContext) _Accelerator(ctx context.Context, sel ast.SelectionSet, obj *schema.Accelerator) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, acceleratorImplementors)

	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("Accelerator")
		case "id":
			out.Values[i] = ec._Accelerator_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec._Accelerator_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "model":
			out.Values[i] = ec._Accelerator_model(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 clusterImplementors = []string{"Cluster"}

func (ec *executionContext) _Cluster(ctx context.Context, sel ast.SelectionSet, obj *schema.Cluster) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, clusterImplementors)

	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("Cluster")
		case "name":
			out.Values[i] = ec._Cluster_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "partitions":
			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._Cluster_partitions(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 "subClusters":
			out.Values[i] = ec._Cluster_subClusters(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

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

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

	return out
}

var clusterMetricWithNameImplementors = []string{"ClusterMetricWithName"}

func (ec *executionContext) _ClusterMetricWithName(ctx context.Context, sel ast.SelectionSet, obj *model.ClusterMetricWithName) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, clusterMetricWithNameImplementors)

	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("ClusterMetricWithName")
		case "name":
			out.Values[i] = ec._ClusterMetricWithName_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "unit":
			out.Values[i] = ec._ClusterMetricWithName_unit(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "timestep":
			out.Values[i] = ec._ClusterMetricWithName_timestep(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._ClusterMetricWithName_data(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 clusterMetricsImplementors = []string{"ClusterMetrics"}

func (ec *executionContext) _ClusterMetrics(ctx context.Context, sel ast.SelectionSet, obj *model.ClusterMetrics) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, clusterMetricsImplementors)

	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("ClusterMetrics")
		case "nodeCount":
			out.Values[i] = ec._ClusterMetrics_nodeCount(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metrics":
			out.Values[i] = ec._ClusterMetrics_metrics(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 clusterSupportImplementors = []string{"ClusterSupport"}

func (ec *executionContext) _ClusterSupport(ctx context.Context, sel ast.SelectionSet, obj *schema.ClusterSupport) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, clusterSupportImplementors)

	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("ClusterSupport")
		case "cluster":
			out.Values[i] = ec._ClusterSupport_cluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "subClusters":
			out.Values[i] = ec._ClusterSupport_subClusters(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 countImplementors = []string{"Count"}

func (ec *executionContext) _Count(ctx context.Context, sel ast.SelectionSet, obj *model.Count) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, countImplementors)

	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("Count")
		case "name":
			out.Values[i] = ec._Count_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._Count_count(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 energyFootprintValueImplementors = []string{"EnergyFootprintValue"}

func (ec *executionContext) _EnergyFootprintValue(ctx context.Context, sel ast.SelectionSet, obj *model.EnergyFootprintValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, energyFootprintValueImplementors)

	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("EnergyFootprintValue")
		case "hardware":
			out.Values[i] = ec._EnergyFootprintValue_hardware(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metric":
			out.Values[i] = ec._EnergyFootprintValue_metric(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "value":
			out.Values[i] = ec._EnergyFootprintValue_value(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 footprintValueImplementors = []string{"FootprintValue"}

func (ec *executionContext) _FootprintValue(ctx context.Context, sel ast.SelectionSet, obj *model.FootprintValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, footprintValueImplementors)

	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("FootprintValue")
		case "name":
			out.Values[i] = ec._FootprintValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "stat":
			out.Values[i] = ec._FootprintValue_stat(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "value":
			out.Values[i] = ec._FootprintValue_value(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 footprintsImplementors = []string{"Footprints"}

func (ec *executionContext) _Footprints(ctx context.Context, sel ast.SelectionSet, obj *model.Footprints) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, footprintsImplementors)

	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("Footprints")
		case "timeWeights":
			out.Values[i] = ec._Footprints_timeWeights(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metrics":
			out.Values[i] = ec._Footprints_metrics(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 globalMetricListItemImplementors = []string{"GlobalMetricListItem"}

func (ec *executionContext) _GlobalMetricListItem(ctx context.Context, sel ast.SelectionSet, obj *schema.GlobalMetricListItem) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, globalMetricListItemImplementors)

	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("GlobalMetricListItem")
		case "name":
			out.Values[i] = ec._GlobalMetricListItem_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "unit":
			out.Values[i] = ec._GlobalMetricListItem_unit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scope":
			out.Values[i] = ec._GlobalMetricListItem_scope(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "footprint":
			out.Values[i] = ec._GlobalMetricListItem_footprint(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "tooltip":
			out.Values[i] = ec._GlobalMetricListItem_tooltip(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "availability":
			out.Values[i] = ec._GlobalMetricListItem_availability(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 histoPointImplementors = []string{"HistoPoint"}

func (ec *executionContext) _HistoPoint(ctx context.Context, sel ast.SelectionSet, obj *model.HistoPoint) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, histoPointImplementors)

	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("HistoPoint")
		case "count":
			out.Values[i] = ec._HistoPoint_count(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "value":
			out.Values[i] = ec._HistoPoint_value(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 intRangeOutputImplementors = []string{"IntRangeOutput"}

func (ec *executionContext) _IntRangeOutput(ctx context.Context, sel ast.SelectionSet, obj *model.IntRangeOutput) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, intRangeOutputImplementors)

	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("IntRangeOutput")
		case "from":
			out.Values[i] = ec._IntRangeOutput_from(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "to":
			out.Values[i] = ec._IntRangeOutput_to(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 jobImplementors = []string{"Job"}

func (ec *executionContext) _Job(ctx context.Context, sel ast.SelectionSet, obj *schema.Job) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobImplementors)

	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("Job")
		case "id":
			out.Values[i] = ec._Job_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "jobId":
			out.Values[i] = ec._Job_jobId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "user":
			out.Values[i] = ec._Job_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "project":
			out.Values[i] = ec._Job_project(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "cluster":
			out.Values[i] = ec._Job_cluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "subCluster":
			out.Values[i] = ec._Job_subCluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "startTime":
			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._Job_startTime(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 "duration":
			out.Values[i] = ec._Job_duration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "walltime":
			out.Values[i] = ec._Job_walltime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "numNodes":
			out.Values[i] = ec._Job_numNodes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "numHWThreads":
			out.Values[i] = ec._Job_numHWThreads(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "numAcc":
			out.Values[i] = ec._Job_numAcc(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "energy":
			out.Values[i] = ec._Job_energy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "SMT":
			out.Values[i] = ec._Job_SMT(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "shared":
			out.Values[i] = ec._Job_shared(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "partition":
			out.Values[i] = ec._Job_partition(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "arrayJobId":
			out.Values[i] = ec._Job_arrayJobId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "monitoringStatus":
			out.Values[i] = ec._Job_monitoringStatus(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "state":
			out.Values[i] = ec._Job_state(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "tags":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Job_tags(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 "resources":
			out.Values[i] = ec._Job_resources(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "concurrentJobs":
			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._Job_concurrentJobs(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 "footprint":
			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._Job_footprint(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 "energyFootprint":
			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._Job_energyFootprint(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 "metaData":
			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._Job_metaData(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 "userData":
			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._Job_userData(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) })
		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 jobLinkImplementors = []string{"JobLink"}

func (ec *executionContext) _JobLink(ctx context.Context, sel ast.SelectionSet, obj *model.JobLink) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobLinkImplementors)

	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("JobLink")
		case "id":
			out.Values[i] = ec._JobLink_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "jobId":
			out.Values[i] = ec._JobLink_jobId(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 jobLinkResultListImplementors = []string{"JobLinkResultList"}

func (ec *executionContext) _JobLinkResultList(ctx context.Context, sel ast.SelectionSet, obj *model.JobLinkResultList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobLinkResultListImplementors)

	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("JobLinkResultList")
		case "listQuery":
			out.Values[i] = ec._JobLinkResultList_listQuery(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "items":
			out.Values[i] = ec._JobLinkResultList_items(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._JobLinkResultList_count(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 jobMetricImplementors = []string{"JobMetric"}

func (ec *executionContext) _JobMetric(ctx context.Context, sel ast.SelectionSet, obj *schema.JobMetric) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobMetricImplementors)

	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("JobMetric")
		case "unit":
			out.Values[i] = ec._JobMetric_unit(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "timestep":
			out.Values[i] = ec._JobMetric_timestep(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "series":
			out.Values[i] = ec._JobMetric_series(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "statisticsSeries":
			out.Values[i] = ec._JobMetric_statisticsSeries(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 jobMetricWithNameImplementors = []string{"JobMetricWithName"}

func (ec *executionContext) _JobMetricWithName(ctx context.Context, sel ast.SelectionSet, obj *model.JobMetricWithName) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobMetricWithNameImplementors)

	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("JobMetricWithName")
		case "name":
			out.Values[i] = ec._JobMetricWithName_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scope":
			out.Values[i] = ec._JobMetricWithName_scope(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metric":
			out.Values[i] = ec._JobMetricWithName_metric(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 jobResultListImplementors = []string{"JobResultList"}

func (ec *executionContext) _JobResultList(ctx context.Context, sel ast.SelectionSet, obj *model.JobResultList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobResultListImplementors)

	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("JobResultList")
		case "items":
			out.Values[i] = ec._JobResultList_items(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "offset":
			out.Values[i] = ec._JobResultList_offset(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "limit":
			out.Values[i] = ec._JobResultList_limit(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._JobResultList_count(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "hasNextPage":
			out.Values[i] = ec._JobResultList_hasNextPage(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 jobStatsImplementors = []string{"JobStats"}

func (ec *executionContext) _JobStats(ctx context.Context, sel ast.SelectionSet, obj *model.JobStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobStatsImplementors)

	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("JobStats")
		case "id":
			out.Values[i] = ec._JobStats_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "jobId":
			out.Values[i] = ec._JobStats_jobId(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "startTime":
			out.Values[i] = ec._JobStats_startTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "duration":
			out.Values[i] = ec._JobStats_duration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cluster":
			out.Values[i] = ec._JobStats_cluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "subCluster":
			out.Values[i] = ec._JobStats_subCluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "numNodes":
			out.Values[i] = ec._JobStats_numNodes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "numHWThreads":
			out.Values[i] = ec._JobStats_numHWThreads(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "numAccelerators":
			out.Values[i] = ec._JobStats_numAccelerators(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "stats":
			out.Values[i] = ec._JobStats_stats(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 jobsStatisticsImplementors = []string{"JobsStatistics"}

func (ec *executionContext) _JobsStatistics(ctx context.Context, sel ast.SelectionSet, obj *model.JobsStatistics) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, jobsStatisticsImplementors)

	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("JobsStatistics")
		case "id":
			out.Values[i] = ec._JobsStatistics_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._JobsStatistics_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalUsers":
			out.Values[i] = ec._JobsStatistics_totalUsers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalJobs":
			out.Values[i] = ec._JobsStatistics_totalJobs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "runningJobs":
			out.Values[i] = ec._JobsStatistics_runningJobs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "shortJobs":
			out.Values[i] = ec._JobsStatistics_shortJobs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalWalltime":
			out.Values[i] = ec._JobsStatistics_totalWalltime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalNodes":
			out.Values[i] = ec._JobsStatistics_totalNodes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalNodeHours":
			out.Values[i] = ec._JobsStatistics_totalNodeHours(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalCores":
			out.Values[i] = ec._JobsStatistics_totalCores(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalCoreHours":
			out.Values[i] = ec._JobsStatistics_totalCoreHours(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalAccs":
			out.Values[i] = ec._JobsStatistics_totalAccs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "totalAccHours":
			out.Values[i] = ec._JobsStatistics_totalAccHours(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "histDuration":
			out.Values[i] = ec._JobsStatistics_histDuration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "histNumNodes":
			out.Values[i] = ec._JobsStatistics_histNumNodes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "histNumCores":
			out.Values[i] = ec._JobsStatistics_histNumCores(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "histNumAccs":
			out.Values[i] = ec._JobsStatistics_histNumAccs(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "histMetrics":
			out.Values[i] = ec._JobsStatistics_histMetrics(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 metricConfigImplementors = []string{"MetricConfig"}

func (ec *executionContext) _MetricConfig(ctx context.Context, sel ast.SelectionSet, obj *schema.MetricConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricConfigImplementors)

	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("MetricConfig")
		case "name":
			out.Values[i] = ec._MetricConfig_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "unit":
			out.Values[i] = ec._MetricConfig_unit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scope":
			out.Values[i] = ec._MetricConfig_scope(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "aggregation":
			out.Values[i] = ec._MetricConfig_aggregation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "timestep":
			out.Values[i] = ec._MetricConfig_timestep(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "peak":
			out.Values[i] = ec._MetricConfig_peak(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "normal":
			out.Values[i] = ec._MetricConfig_normal(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "caution":
			out.Values[i] = ec._MetricConfig_caution(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "alert":
			out.Values[i] = ec._MetricConfig_alert(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "lowerIsBetter":
			out.Values[i] = ec._MetricConfig_lowerIsBetter(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "subClusters":
			out.Values[i] = ec._MetricConfig_subClusters(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "tooltip":
			out.Values[i] = ec._MetricConfig_tooltip(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 metricFootprintsImplementors = []string{"MetricFootprints"}

func (ec *executionContext) _MetricFootprints(ctx context.Context, sel ast.SelectionSet, obj *model.MetricFootprints) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricFootprintsImplementors)

	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("MetricFootprints")
		case "metric":
			out.Values[i] = ec._MetricFootprints_metric(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._MetricFootprints_data(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 metricHistoPointImplementors = []string{"MetricHistoPoint"}

func (ec *executionContext) _MetricHistoPoint(ctx context.Context, sel ast.SelectionSet, obj *model.MetricHistoPoint) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricHistoPointImplementors)

	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("MetricHistoPoint")
		case "bin":
			out.Values[i] = ec._MetricHistoPoint_bin(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._MetricHistoPoint_count(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "min":
			out.Values[i] = ec._MetricHistoPoint_min(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "max":
			out.Values[i] = ec._MetricHistoPoint_max(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 metricHistoPointsImplementors = []string{"MetricHistoPoints"}

func (ec *executionContext) _MetricHistoPoints(ctx context.Context, sel ast.SelectionSet, obj *model.MetricHistoPoints) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricHistoPointsImplementors)

	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("MetricHistoPoints")
		case "metric":
			out.Values[i] = ec._MetricHistoPoints_metric(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "unit":
			out.Values[i] = ec._MetricHistoPoints_unit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "stat":
			out.Values[i] = ec._MetricHistoPoints_stat(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._MetricHistoPoints_data(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 metricStatisticsImplementors = []string{"MetricStatistics"}

func (ec *executionContext) _MetricStatistics(ctx context.Context, sel ast.SelectionSet, obj *schema.MetricStatistics) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricStatisticsImplementors)

	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("MetricStatistics")
		case "avg":
			out.Values[i] = ec._MetricStatistics_avg(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "min":
			out.Values[i] = ec._MetricStatistics_min(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "max":
			out.Values[i] = ec._MetricStatistics_max(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 metricValueImplementors = []string{"MetricValue"}

func (ec *executionContext) _MetricValue(ctx context.Context, sel ast.SelectionSet, obj *schema.MetricValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, metricValueImplementors)

	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("MetricValue")
		case "name":
			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._MetricValue_name(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 "unit":
			out.Values[i] = ec._MetricValue_unit(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "value":
			out.Values[i] = ec._MetricValue_value(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

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

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

	return out
}

var mutationImplementors = []string{"Mutation"}

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

	out := graphql.NewFieldSet(fields)
	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("Mutation")
		case "createTag":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_createTag(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deleteTag":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_deleteTag(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "addTagsToJob":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_addTagsToJob(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "removeTagsFromJob":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_removeTagsFromJob(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "removeTagFromList":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_removeTagFromList(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "updateConfiguration":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_updateConfiguration(ctx, field)
			})
			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 namedStatsImplementors = []string{"NamedStats"}

func (ec *executionContext) _NamedStats(ctx context.Context, sel ast.SelectionSet, obj *model.NamedStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, namedStatsImplementors)

	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("NamedStats")
		case "name":
			out.Values[i] = ec._NamedStats_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._NamedStats_data(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 namedStatsWithScopeImplementors = []string{"NamedStatsWithScope"}

func (ec *executionContext) _NamedStatsWithScope(ctx context.Context, sel ast.SelectionSet, obj *model.NamedStatsWithScope) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, namedStatsWithScopeImplementors)

	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("NamedStatsWithScope")
		case "name":
			out.Values[i] = ec._NamedStatsWithScope_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scope":
			out.Values[i] = ec._NamedStatsWithScope_scope(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "stats":
			out.Values[i] = ec._NamedStatsWithScope_stats(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 nodeImplementors = []string{"Node"}

func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj *schema.Node) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodeImplementors)

	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("Node")
		case "id":
			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._Node_id(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 "hostname":
			out.Values[i] = ec._Node_hostname(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "cluster":
			out.Values[i] = ec._Node_cluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "subCluster":
			out.Values[i] = ec._Node_subCluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "jobsRunning":
			out.Values[i] = ec._Node_jobsRunning(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "cpusAllocated":
			out.Values[i] = ec._Node_cpusAllocated(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "memoryAllocated":
			out.Values[i] = ec._Node_memoryAllocated(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "gpusAllocated":
			out.Values[i] = ec._Node_gpusAllocated(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "schedulerState":
			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._Node_schedulerState(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 "healthState":
			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._Node_healthState(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 "metaData":
			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._Node_metaData(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 "healthData":
			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._Node_healthData(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) })
		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 nodeMetricsImplementors = []string{"NodeMetrics"}

func (ec *executionContext) _NodeMetrics(ctx context.Context, sel ast.SelectionSet, obj *model.NodeMetrics) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodeMetricsImplementors)

	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("NodeMetrics")
		case "host":
			out.Values[i] = ec._NodeMetrics_host(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "nodeState":
			out.Values[i] = ec._NodeMetrics_nodeState(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metricHealth":
			out.Values[i] = ec._NodeMetrics_metricHealth(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "subCluster":
			out.Values[i] = ec._NodeMetrics_subCluster(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "metrics":
			out.Values[i] = ec._NodeMetrics_metrics(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 nodeStateResultListImplementors = []string{"NodeStateResultList"}

func (ec *executionContext) _NodeStateResultList(ctx context.Context, sel ast.SelectionSet, obj *model.NodeStateResultList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodeStateResultListImplementors)

	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("NodeStateResultList")
		case "items":
			out.Values[i] = ec._NodeStateResultList_items(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._NodeStateResultList_count(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 nodeStatesImplementors = []string{"NodeStates"}

func (ec *executionContext) _NodeStates(ctx context.Context, sel ast.SelectionSet, obj *model.NodeStates) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodeStatesImplementors)

	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("NodeStates")
		case "state":
			out.Values[i] = ec._NodeStates_state(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._NodeStates_count(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 nodeStatesTimedImplementors = []string{"NodeStatesTimed"}

func (ec *executionContext) _NodeStatesTimed(ctx context.Context, sel ast.SelectionSet, obj *model.NodeStatesTimed) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodeStatesTimedImplementors)

	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("NodeStatesTimed")
		case "state":
			out.Values[i] = ec._NodeStatesTimed_state(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "counts":
			out.Values[i] = ec._NodeStatesTimed_counts(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "times":
			out.Values[i] = ec._NodeStatesTimed_times(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 nodesResultListImplementors = []string{"NodesResultList"}

func (ec *executionContext) _NodesResultList(ctx context.Context, sel ast.SelectionSet, obj *model.NodesResultList) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nodesResultListImplementors)

	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("NodesResultList")
		case "items":
			out.Values[i] = ec._NodesResultList_items(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "offset":
			out.Values[i] = ec._NodesResultList_offset(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "limit":
			out.Values[i] = ec._NodesResultList_limit(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "count":
			out.Values[i] = ec._NodesResultList_count(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "totalNodes":
			out.Values[i] = ec._NodesResultList_totalNodes(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "hasNextPage":
			out.Values[i] = ec._NodesResultList_hasNextPage(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 "clusters":
			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_clusters(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

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

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

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

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

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "globalMetrics":
			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_globalMetrics(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 "user":
			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_user(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 "allocatedNodes":
			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_allocatedNodes(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 "node":
			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_node(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 "nodes":
			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_nodes(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 "nodesWithMeta":
			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_nodesWithMeta(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 "nodeStates":
			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_nodeStates(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 "nodeStatesTimed":
			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_nodeStatesTimed(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 "job":
			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_job(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 "jobMetrics":
			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_jobMetrics(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 "jobStats":
			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_jobStats(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 "scopedJobStats":
			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_scopedJobStats(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 "jobs":
			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_jobs(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 "jobsStatistics":
			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_jobsStatistics(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 "jobsMetricStats":
			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_jobsMetricStats(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 "jobsFootprints":
			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_jobsFootprints(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 "rooflineHeatmap":
			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_rooflineHeatmap(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 "nodeMetrics":
			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_nodeMetrics(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 "nodeMetricsList":
			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_nodeMetricsList(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 "clusterMetrics":
			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_clusterMetrics(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

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

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "__type":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___type(ctx, field)
			})
			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 resourceImplementors = []string{"Resource"}

func (ec *executionContext) _Resource(ctx context.Context, sel ast.SelectionSet, obj *schema.Resource) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, resourceImplementors)

	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("Resource")
		case "hostname":
			out.Values[i] = ec._Resource_hostname(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "hwthreads":
			out.Values[i] = ec._Resource_hwthreads(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "accelerators":
			out.Values[i] = ec._Resource_accelerators(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "configuration":
			out.Values[i] = ec._Resource_configuration(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 scopedStatsImplementors = []string{"ScopedStats"}

func (ec *executionContext) _ScopedStats(ctx context.Context, sel ast.SelectionSet, obj *model.ScopedStats) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, scopedStatsImplementors)

	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("ScopedStats")
		case "hostname":
			out.Values[i] = ec._ScopedStats_hostname(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "id":
			out.Values[i] = ec._ScopedStats_id(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._ScopedStats_data(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 seriesImplementors = []string{"Series"}

func (ec *executionContext) _Series(ctx context.Context, sel ast.SelectionSet, obj *schema.Series) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, seriesImplementors)

	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("Series")
		case "hostname":
			out.Values[i] = ec._Series_hostname(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "id":
			out.Values[i] = ec._Series_id(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "statistics":
			out.Values[i] = ec._Series_statistics(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "data":
			out.Values[i] = ec._Series_data(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 statsSeriesImplementors = []string{"StatsSeries"}

func (ec *executionContext) _StatsSeries(ctx context.Context, sel ast.SelectionSet, obj *schema.StatsSeries) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, statsSeriesImplementors)

	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("StatsSeries")
		case "mean":
			out.Values[i] = ec._StatsSeries_mean(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "median":
			out.Values[i] = ec._StatsSeries_median(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "min":
			out.Values[i] = ec._StatsSeries_min(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "max":
			out.Values[i] = ec._StatsSeries_max(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 subClusterImplementors = []string{"SubCluster"}

func (ec *executionContext) _SubCluster(ctx context.Context, sel ast.SelectionSet, obj *schema.SubCluster) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, subClusterImplementors)

	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("SubCluster")
		case "name":
			out.Values[i] = ec._SubCluster_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "nodes":
			out.Values[i] = ec._SubCluster_nodes(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "numberOfNodes":
			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._SubCluster_numberOfNodes(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 "processorType":
			out.Values[i] = ec._SubCluster_processorType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "socketsPerNode":
			out.Values[i] = ec._SubCluster_socketsPerNode(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "coresPerSocket":
			out.Values[i] = ec._SubCluster_coresPerSocket(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "threadsPerCore":
			out.Values[i] = ec._SubCluster_threadsPerCore(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "flopRateScalar":
			out.Values[i] = ec._SubCluster_flopRateScalar(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "flopRateSimd":
			out.Values[i] = ec._SubCluster_flopRateSimd(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "memoryBandwidth":
			out.Values[i] = ec._SubCluster_memoryBandwidth(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "topology":
			out.Values[i] = ec._SubCluster_topology(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "metricConfig":
			out.Values[i] = ec._SubCluster_metricConfig(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		case "footprint":
			out.Values[i] = ec._SubCluster_footprint(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&out.Invalids, 1)
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

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

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

	return out
}

var subClusterConfigImplementors = []string{"SubClusterConfig"}

func (ec *executionContext) _SubClusterConfig(ctx context.Context, sel ast.SelectionSet, obj *schema.SubClusterConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, subClusterConfigImplementors)

	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("SubClusterConfig")
		case "name":
			out.Values[i] = ec._SubClusterConfig_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "peak":
			out.Values[i] = ec._SubClusterConfig_peak(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "normal":
			out.Values[i] = ec._SubClusterConfig_normal(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "caution":
			out.Values[i] = ec._SubClusterConfig_caution(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "alert":
			out.Values[i] = ec._SubClusterConfig_alert(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "remove":
			out.Values[i] = ec._SubClusterConfig_remove(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 tagImplementors = []string{"Tag"}

func (ec *executionContext) _Tag(ctx context.Context, sel ast.SelectionSet, obj *schema.Tag) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, tagImplementors)

	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("Tag")
		case "id":
			out.Values[i] = ec._Tag_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec._Tag_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._Tag_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "scope":
			out.Values[i] = ec._Tag_scope(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 timeRangeOutputImplementors = []string{"TimeRangeOutput"}

func (ec *executionContext) _TimeRangeOutput(ctx context.Context, sel ast.SelectionSet, obj *model.TimeRangeOutput) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, timeRangeOutputImplementors)

	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("TimeRangeOutput")
		case "range":
			out.Values[i] = ec._TimeRangeOutput_range(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "from":
			out.Values[i] = ec._TimeRangeOutput_from(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "to":
			out.Values[i] = ec._TimeRangeOutput_to(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 timeWeightsImplementors = []string{"TimeWeights"}

func (ec *executionContext) _TimeWeights(ctx context.Context, sel ast.SelectionSet, obj *model.TimeWeights) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, timeWeightsImplementors)

	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("TimeWeights")
		case "nodeHours":
			out.Values[i] = ec._TimeWeights_nodeHours(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "accHours":
			out.Values[i] = ec._TimeWeights_accHours(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "coreHours":
			out.Values[i] = ec._TimeWeights_coreHours(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 topologyImplementors = []string{"Topology"}

func (ec *executionContext) _Topology(ctx context.Context, sel ast.SelectionSet, obj *schema.Topology) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, topologyImplementors)

	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("Topology")
		case "node":
			out.Values[i] = ec._Topology_node(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "socket":
			out.Values[i] = ec._Topology_socket(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "memoryDomain":
			out.Values[i] = ec._Topology_memoryDomain(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "die":
			out.Values[i] = ec._Topology_die(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "core":
			out.Values[i] = ec._Topology_core(ctx, field, obj)
			if out.Values[i] == graphql.RequiredNull {
				out.Invalids++
			}
		case "accelerators":
			out.Values[i] = ec._Topology_accelerators(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 unitImplementors = []string{"Unit"}

func (ec *executionContext) _Unit(ctx context.Context, sel ast.SelectionSet, obj *schema.Unit) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, unitImplementors)

	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("Unit")
		case "base":
			out.Values[i] = ec._Unit_base(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "prefix":
			out.Values[i] = ec._Unit_prefix(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 userImplementors = []string{"User"}

func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *model.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 "name":
			out.Values[i] = ec._User_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "email":
			out.Values[i] = ec._User_email(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) marshalNAccelerator2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐAccelerator(ctx context.Context, sel ast.SelectionSet, v *schema.Accelerator) 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._Accelerator(ctx, sel, v)
}

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

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

func (ec *executionContext) marshalNCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Cluster) 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.marshalNCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐCluster(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐCluster(ctx context.Context, sel ast.SelectionSet, v *schema.Cluster) 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._Cluster(ctx, sel, v)
}

func (ec *executionContext) marshalNClusterMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetricWithNameᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.ClusterMetricWithName) 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.marshalNClusterMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetricWithName(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNClusterMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetricWithName(ctx context.Context, sel ast.SelectionSet, v *model.ClusterMetricWithName) 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._ClusterMetricWithName(ctx, sel, v)
}

func (ec *executionContext) marshalNClusterMetrics2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetrics(ctx context.Context, sel ast.SelectionSet, v model.ClusterMetrics) graphql.Marshaler {
	return ec._ClusterMetrics(ctx, sel, &v)
}

func (ec *executionContext) marshalNClusterMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐClusterMetrics(ctx context.Context, sel ast.SelectionSet, v *model.ClusterMetrics) 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._ClusterMetrics(ctx, sel, v)
}

func (ec *executionContext) marshalNClusterSupport2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterSupport(ctx context.Context, sel ast.SelectionSet, v schema.ClusterSupport) graphql.Marshaler {
	return ec._ClusterSupport(ctx, sel, &v)
}

func (ec *executionContext) marshalNClusterSupport2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterSupportᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.ClusterSupport) 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.marshalNClusterSupport2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐClusterSupport(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNCount2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐCountᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Count) 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.marshalNCount2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐCount(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNCount2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐCount(ctx context.Context, sel ast.SelectionSet, v *model.Count) 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._Count(ctx, sel, v)
}

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

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

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

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

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

	return ret
}

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

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

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

	return ret
}

func (ec *executionContext) unmarshalNFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFloatRange(ctx context.Context, v any) (*model.FloatRange, error) {
	res, err := ec.unmarshalInputFloatRange(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNGlobalMetricListItem2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐGlobalMetricListItemᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.GlobalMetricListItem) 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.marshalNGlobalMetricListItem2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐGlobalMetricListItem(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNGlobalMetricListItem2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐGlobalMetricListItem(ctx context.Context, sel ast.SelectionSet, v *schema.GlobalMetricListItem) 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._GlobalMetricListItem(ctx, sel, v)
}

func (ec *executionContext) marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPointᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.HistoPoint) 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.marshalNHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPoint(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐHistoPoint(ctx context.Context, sel ast.SelectionSet, v *model.HistoPoint) 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._HistoPoint(ctx, sel, v)
}

func (ec *executionContext) unmarshalNID2int64(ctx context.Context, v any) (int64, error) {
	res, err := graphql.UnmarshalInt64(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2int64(ctx context.Context, sel ast.SelectionSet, v int64) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalInt64(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) unmarshalNID2string(ctx context.Context, v any) (string, error) {
	res, err := graphql.UnmarshalID(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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

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

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

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

	return ret
}

func (ec *executionContext) unmarshalNID2ᚖint64(ctx context.Context, v any) (*int64, error) {
	res, err := graphql.UnmarshalInt64(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2ᚖint64(ctx context.Context, sel ast.SelectionSet, v *int64) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	_ = sel
	res := graphql.MarshalInt64(*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) unmarshalNInt2int(ctx context.Context, v any) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

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

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

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

func (ec *executionContext) unmarshalNInt2int64(ctx context.Context, v any) (int64, error) {
	res, err := graphql.UnmarshalInt64(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInt2int64(ctx context.Context, sel ast.SelectionSet, v int64) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalInt64(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) unmarshalNInt2ᚕintᚄ(ctx context.Context, v any) ([]int, error) {
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]int, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

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

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

	return ret
}

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

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

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

	return ret
}

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

func (ec *executionContext) marshalNInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	_ = sel
	res := graphql.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) marshalNJob2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Job) 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.marshalNJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJob(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJob(ctx context.Context, sel ast.SelectionSet, v *schema.Job) 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._Job(ctx, sel, v)
}

func (ec *executionContext) unmarshalNJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx context.Context, v any) ([]*model.JobFilter, error) {
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]*model.JobFilter, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilter(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilter(ctx context.Context, v any) (*model.JobFilter, error) {
	res, err := ec.unmarshalInputJobFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNJobLink2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLinkᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobLink) 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.marshalNJobLink2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLink(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNJobLink2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLink(ctx context.Context, sel ast.SelectionSet, v *model.JobLink) 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._JobLink(ctx, sel, v)
}

func (ec *executionContext) marshalNJobMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobMetric(ctx context.Context, sel ast.SelectionSet, v *schema.JobMetric) 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._JobMetric(ctx, sel, v)
}

func (ec *executionContext) marshalNJobMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobMetricWithNameᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobMetricWithName) 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.marshalNJobMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobMetricWithName(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNJobMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobMetricWithName(ctx context.Context, sel ast.SelectionSet, v *model.JobMetricWithName) 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._JobMetricWithName(ctx, sel, v)
}

func (ec *executionContext) marshalNJobResultList2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobResultList(ctx context.Context, sel ast.SelectionSet, v model.JobResultList) graphql.Marshaler {
	return ec._JobResultList(ctx, sel, &v)
}

func (ec *executionContext) marshalNJobResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobResultList(ctx context.Context, sel ast.SelectionSet, v *model.JobResultList) 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._JobResultList(ctx, sel, v)
}

func (ec *executionContext) unmarshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobState(ctx context.Context, v any) (schema.JobState, error) {
	var res schema.JobState
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobState(ctx context.Context, sel ast.SelectionSet, v schema.JobState) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNJobStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobStats) 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.marshalNJobStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobStats(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNJobStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobStats(ctx context.Context, sel ast.SelectionSet, v *model.JobStats) 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._JobStats(ctx, sel, v)
}

func (ec *executionContext) marshalNJobsStatistics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobsStatisticsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobsStatistics) 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.marshalNJobsStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobsStatistics(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNJobsStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobsStatistics(ctx context.Context, sel ast.SelectionSet, v *model.JobsStatistics) 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._JobsStatistics(ctx, sel, v)
}

func (ec *executionContext) marshalNMetricConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricConfigᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.MetricConfig) 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.marshalNMetricConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricConfig(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNMetricConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricConfig(ctx context.Context, sel ast.SelectionSet, v *schema.MetricConfig) 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._MetricConfig(ctx, sel, v)
}

func (ec *executionContext) marshalNMetricFootprints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricFootprintsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MetricFootprints) 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.marshalNMetricFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricFootprints(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNMetricFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricFootprints(ctx context.Context, sel ast.SelectionSet, v *model.MetricFootprints) 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._MetricFootprints(ctx, sel, v)
}

func (ec *executionContext) marshalNMetricHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPoint(ctx context.Context, sel ast.SelectionSet, v *model.MetricHistoPoint) 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._MetricHistoPoint(ctx, sel, v)
}

func (ec *executionContext) marshalNMetricHistoPoints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPointsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MetricHistoPoints) 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.marshalNMetricHistoPoints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPoints(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNMetricHistoPoints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPoints(ctx context.Context, sel ast.SelectionSet, v *model.MetricHistoPoints) 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._MetricHistoPoints(ctx, sel, v)
}

func (ec *executionContext) unmarshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx context.Context, v any) (schema.MetricScope, error) {
	var res schema.MetricScope
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx context.Context, sel ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNMetricStatItem2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricStatItem(ctx context.Context, v any) (*model.MetricStatItem, error) {
	res, err := ec.unmarshalInputMetricStatItem(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNMetricStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricStatistics(ctx context.Context, sel ast.SelectionSet, v *schema.MetricStatistics) 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._MetricStatistics(ctx, sel, v)
}

func (ec *executionContext) marshalNMetricValue2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricValue(ctx context.Context, sel ast.SelectionSet, v schema.MetricValue) graphql.Marshaler {
	return ec._MetricValue(ctx, sel, &v)
}

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

func (ec *executionContext) marshalNMonitoringState2string(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) marshalNNamedStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NamedStats) 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.marshalNNamedStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStats(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNamedStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStats(ctx context.Context, sel ast.SelectionSet, v *model.NamedStats) 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._NamedStats(ctx, sel, v)
}

func (ec *executionContext) marshalNNamedStatsWithScope2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsWithScopeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NamedStatsWithScope) 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.marshalNNamedStatsWithScope2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsWithScope(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNamedStatsWithScope2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNamedStatsWithScope(ctx context.Context, sel ast.SelectionSet, v *model.NamedStatsWithScope) 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._NamedStatsWithScope(ctx, sel, v)
}

func (ec *executionContext) marshalNNode2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNodeᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Node) 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.marshalNNode2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNode(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNode2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNode(ctx context.Context, sel ast.SelectionSet, v *schema.Node) 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._Node(ctx, sel, v)
}

func (ec *executionContext) unmarshalNNodeFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilter(ctx context.Context, v any) (*model.NodeFilter, error) {
	res, err := ec.unmarshalInputNodeFilter(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNNodeMetrics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeMetricsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NodeMetrics) 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.marshalNNodeMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeMetrics(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNodeMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeMetrics(ctx context.Context, sel ast.SelectionSet, v *model.NodeMetrics) 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._NodeMetrics(ctx, sel, v)
}

func (ec *executionContext) marshalNNodeStateResultList2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStateResultList(ctx context.Context, sel ast.SelectionSet, v model.NodeStateResultList) graphql.Marshaler {
	return ec._NodeStateResultList(ctx, sel, &v)
}

func (ec *executionContext) marshalNNodeStateResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStateResultList(ctx context.Context, sel ast.SelectionSet, v *model.NodeStateResultList) 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._NodeStateResultList(ctx, sel, v)
}

func (ec *executionContext) marshalNNodeStates2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NodeStates) 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.marshalNNodeStates2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStates(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNodeStates2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStates(ctx context.Context, sel ast.SelectionSet, v *model.NodeStates) 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._NodeStates(ctx, sel, v)
}

func (ec *executionContext) marshalNNodeStatesTimed2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesTimedᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NodeStatesTimed) 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.marshalNNodeStatesTimed2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesTimed(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNNodeStatesTimed2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeStatesTimed(ctx context.Context, sel ast.SelectionSet, v *model.NodeStatesTimed) 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._NodeStatesTimed(ctx, sel, v)
}

func (ec *executionContext) marshalNNodesResultList2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodesResultList(ctx context.Context, sel ast.SelectionSet, v model.NodesResultList) graphql.Marshaler {
	return ec._NodesResultList(ctx, sel, &v)
}

func (ec *executionContext) marshalNNodesResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodesResultList(ctx context.Context, sel ast.SelectionSet, v *model.NodesResultList) 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._NodesResultList(ctx, sel, v)
}

func (ec *executionContext) unmarshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloat(ctx context.Context, v any) (schema.Float, error) {
	var res schema.Float
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloat(ctx context.Context, sel ast.SelectionSet, v schema.Float) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx context.Context, v any) ([]schema.Float, error) {
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]schema.Float, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloat(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloatᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.Float) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐFloat(ctx, sel, v[i])
	}

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

	return ret
}

func (ec *executionContext) marshalNResource2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐResourceᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Resource) 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.marshalNResource2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐResource(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNResource2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐResource(ctx context.Context, sel ast.SelectionSet, v *schema.Resource) 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._Resource(ctx, sel, v)
}

func (ec *executionContext) unmarshalNSchedulerState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx context.Context, v any) (schema.SchedulerState, error) {
	tmp, err := graphql.UnmarshalString(v)
	res := schema.SchedulerState(tmp)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSchedulerState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx context.Context, sel ast.SelectionSet, v schema.SchedulerState) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalString(string(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) marshalNScopedStats2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐScopedStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.ScopedStats) 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.marshalNScopedStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐScopedStats(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNScopedStats2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐScopedStats(ctx context.Context, sel ast.SelectionSet, v *model.ScopedStats) 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._ScopedStats(ctx, sel, v)
}

func (ec *executionContext) marshalNSeries2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSeries(ctx context.Context, sel ast.SelectionSet, v schema.Series) graphql.Marshaler {
	return ec._Series(ctx, sel, &v)
}

func (ec *executionContext) unmarshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortDirectionEnum(ctx context.Context, v any) (model.SortDirectionEnum, error) {
	var res model.SortDirectionEnum
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortDirectionEnum(ctx context.Context, sel ast.SelectionSet, v model.SortDirectionEnum) graphql.Marshaler {
	return v
}

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

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

func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	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) marshalNSubCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.SubCluster) 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.marshalNSubCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubCluster(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNSubCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubCluster(ctx context.Context, sel ast.SelectionSet, v *schema.SubCluster) 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._SubCluster(ctx, sel, v)
}

func (ec *executionContext) marshalNSubClusterConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterConfigᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.SubClusterConfig) 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.marshalNSubClusterConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterConfig(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNSubClusterConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSubClusterConfig(ctx context.Context, sel ast.SelectionSet, v *schema.SubClusterConfig) 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._SubClusterConfig(ctx, sel, v)
}

func (ec *executionContext) marshalNTag2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTag(ctx context.Context, sel ast.SelectionSet, v schema.Tag) graphql.Marshaler {
	return ec._Tag(ctx, sel, &v)
}

func (ec *executionContext) marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTagᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Tag) 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.marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTag(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTag(ctx context.Context, sel ast.SelectionSet, v *schema.Tag) 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._Tag(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) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v any) (*time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

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

func (ec *executionContext) marshalNTimeWeights2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐTimeWeights(ctx context.Context, sel ast.SelectionSet, v *model.TimeWeights) 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._TimeWeights(ctx, sel, v)
}

func (ec *executionContext) marshalNTopology2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐTopology(ctx context.Context, sel ast.SelectionSet, v schema.Topology) graphql.Marshaler {
	return ec._Topology(ctx, sel, &v)
}

func (ec *executionContext) marshalNUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx context.Context, sel ast.SelectionSet, v schema.Unit) graphql.Marshaler {
	return ec._Unit(ctx, sel, &v)
}

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

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

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

	return ret
}

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

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

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
	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) marshalOAccelerator2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐAcceleratorᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Accelerator) 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.marshalNAccelerator2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐAccelerator(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) unmarshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐAggregate(ctx context.Context, v any) (*model.Aggregate, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(model.Aggregate)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐAggregate(ctx context.Context, sel ast.SelectionSet, v *model.Aggregate) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) unmarshalOAny2interface(ctx context.Context, v any) (any, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalAny(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOAny2interface(ctx context.Context, sel ast.SelectionSet, v any) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalAny(v)
	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) marshalOEnergyFootprintValue2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐEnergyFootprintValue(ctx context.Context, sel ast.SelectionSet, v []*model.EnergyFootprintValue) 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.marshalOEnergyFootprintValue2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐEnergyFootprintValue(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalOEnergyFootprintValue2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐEnergyFootprintValue(ctx context.Context, sel ast.SelectionSet, v *model.EnergyFootprintValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._EnergyFootprintValue(ctx, sel, v)
}

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

func (ec *executionContext) marshalOFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
	_ = sel
	res := graphql.MarshalFloatContext(v)
	return graphql.WrapContextMarshaler(ctx, res)
}

func (ec *executionContext) unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFloatRange(ctx context.Context, v any) (*model.FloatRange, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputFloatRange(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOFootprintValue2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprintValue(ctx context.Context, sel ast.SelectionSet, v []*model.FootprintValue) 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.marshalOFootprintValue2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprintValue(ctx, sel, v[i])
	})

	return ret
}

func (ec *executionContext) marshalOFootprintValue2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprintValue(ctx context.Context, sel ast.SelectionSet, v *model.FootprintValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._FootprintValue(ctx, sel, v)
}

func (ec *executionContext) marshalOFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐFootprints(ctx context.Context, sel ast.SelectionSet, v *model.Footprints) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Footprints(ctx, sel, v)
}

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

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

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

	return ret
}

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

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

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

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

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

	return ret
}

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

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

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

	return ret
}

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

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

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

	return ret
}

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) unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐIntRange(ctx context.Context, v any) (*config.IntRange, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputIntRange(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJob(ctx context.Context, sel ast.SelectionSet, v *schema.Job) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Job(ctx, sel, v)
}

func (ec *executionContext) unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilterᚄ(ctx context.Context, v any) ([]*model.JobFilter, error) {
	if v == nil {
		return nil, nil
	}
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]*model.JobFilter, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobFilter(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOJobLinkResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐJobLinkResultList(ctx context.Context, sel ast.SelectionSet, v *model.JobLinkResultList) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._JobLinkResultList(ctx, sel, v)
}

func (ec *executionContext) unmarshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobStateᚄ(ctx context.Context, v any) ([]schema.JobState, error) {
	if v == nil {
		return nil, nil
	}
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]schema.JobState, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobState(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobStateᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.JobState) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐJobState(ctx, sel, v[i])
	}

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

	return ret
}

func (ec *executionContext) marshalOMetricHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPointᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MetricHistoPoint) 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.marshalNMetricHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricHistoPoint(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx context.Context, v any) ([]schema.MetricScope, error) {
	if v == nil {
		return nil, nil
	}
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]schema.MetricScope, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScopeᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.MetricScope) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricScope(ctx, sel, v[i])
	}

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

	return ret
}

func (ec *executionContext) unmarshalOMetricStatItem2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricStatItemᚄ(ctx context.Context, v any) ([]*model.MetricStatItem, error) {
	if v == nil {
		return nil, nil
	}
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]*model.MetricStatItem, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNMetricStatItem2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐMetricStatItem(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOMetricStatistics2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐMetricStatistics(ctx context.Context, sel ast.SelectionSet, v schema.MetricStatistics) graphql.Marshaler {
	return ec._MetricStatistics(ctx, sel, &v)
}

func (ec *executionContext) unmarshalOMonitoringState2ᚖ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) marshalOMonitoringState2ᚖ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) marshalONode2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐNode(ctx context.Context, sel ast.SelectionSet, v *schema.Node) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Node(ctx, sel, v)
}

func (ec *executionContext) unmarshalONodeFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilterᚄ(ctx context.Context, v any) ([]*model.NodeFilter, error) {
	if v == nil {
		return nil, nil
	}
	vSlice := graphql.CoerceList(v)
	var err error
	res := make([]*model.NodeFilter, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNNodeFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐNodeFilter(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐOrderByInput(ctx context.Context, v any) (*model.OrderByInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputOrderByInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐPageRequest(ctx context.Context, v any) (*model.PageRequest, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPageRequest(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOResampleAlgo2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐResampleAlgo(ctx context.Context, v any) (*model.ResampleAlgo, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(model.ResampleAlgo)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOResampleAlgo2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐResampleAlgo(ctx context.Context, sel ast.SelectionSet, v *model.ResampleAlgo) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) unmarshalOSchedulerState2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx context.Context, v any) (*schema.SchedulerState, error) {
	if v == nil {
		return nil, nil
	}
	tmp, err := graphql.UnmarshalString(v)
	res := schema.SchedulerState(tmp)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSchedulerState2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSchedulerState(ctx context.Context, sel ast.SelectionSet, v *schema.SchedulerState) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	_ = sel
	_ = ctx
	res := graphql.MarshalString(string(*v))
	return res
}

func (ec *executionContext) marshalOSeries2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSeriesᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.Series) 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.marshalNSeries2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐSeries(ctx, sel, v[i])
	})

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

	return ret
}

func (ec *executionContext) unmarshalOSortByAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortByAggregate(ctx context.Context, v any) (*model.SortByAggregate, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(model.SortByAggregate)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOSortByAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐSortByAggregate(ctx context.Context, sel ast.SelectionSet, v *model.SortByAggregate) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalOStatsSeries2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐStatsSeries(ctx context.Context, sel ast.SelectionSet, v *schema.StatsSeries) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._StatsSeries(ctx, sel, v)
}

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

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

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

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

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

	return ret
}

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

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

func (ec *executionContext) unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐStringInput(ctx context.Context, v any) (*model.StringInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputStringInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

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

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

func (ec *executionContext) unmarshalOTimeRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋconfigᚐTimeRange(ctx context.Context, v any) (*config.TimeRange, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTimeRange(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOUnit2githubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx context.Context, sel ast.SelectionSet, v schema.Unit) graphql.Marshaler {
	return ec._Unit(ctx, sel, &v)
}

func (ec *executionContext) marshalOUnit2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑlibᚋv2ᚋschemaᚐUnit(ctx context.Context, sel ast.SelectionSet, v *schema.Unit) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Unit(ctx, sel, v)
}

func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑbackendᚋinternalᚋgraphᚋmodelᚐUser(ctx context.Context, sel ast.SelectionSet, v *model.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 *****************************
