graphql.go

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

package models

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

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

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

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

type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

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

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	Action struct {
		AnimationLockTime func(childComplexity int) int
		EffectDisplayType func(childComplexity int) int
		EffectFlags       func(childComplexity int) int
		Effects           func(childComplexity int) int
		GlobalCounter     func(childComplexity int) int
		HiddenAnimation   func(childComplexity int) int
		ID                func(childComplexity int) int
		IsAoE             func(childComplexity int) int
		Location          func(childComplexity int) int
		Name              func(childComplexity int) int
		TargetID          func(childComplexity int) int
		UseTime           func(childComplexity int) int
		Variation         func(childComplexity int) int
	}

	ActionEffect struct {
		BonusPercent    func(childComplexity int) int
		Flags           func(childComplexity int) int
		HitSeverity     func(childComplexity int) int
		Param           func(childComplexity int) int
		TargetID        func(childComplexity int) int
		Type            func(childComplexity int) int
		Value           func(childComplexity int) int
		ValueMultiplier func(childComplexity int) int
	}

	AddEntity struct {
		Entity func(childComplexity int) int
	}

	AddStream struct {
		Stream func(childComplexity int) int
	}

	CastingInfo struct {
		ActionID      func(childComplexity int) int
		ActionName    func(childComplexity int) int
		CastTime      func(childComplexity int) int
		CastType      func(childComplexity int) int
		EffectRange   func(childComplexity int) int
		Location      func(childComplexity int) int
		Omen          func(childComplexity int) int
		StartTime     func(childComplexity int) int
		TargetID      func(childComplexity int) int
		XAxisModifier func(childComplexity int) int
	}

	ChatEvent struct {
		ChannelID    func(childComplexity int) int
		ChannelType  func(childComplexity int) int
		ChannelWorld func(childComplexity int) int
		ContentID    func(childComplexity int) int
		EntityID     func(childComplexity int) int
		Message      func(childComplexity int) int
		Name         func(childComplexity int) int
		World        func(childComplexity int) int
	}

	ClassJob struct {
		Abbreviation func(childComplexity int) int
		ID           func(childComplexity int) int
		Name         func(childComplexity int) int
	}

	CraftingInfo struct {
		CurrentCondition    func(childComplexity int) int
		Durability          func(childComplexity int) int
		DurabilityDelta     func(childComplexity int) int
		HqChance            func(childComplexity int) int
		LastCraftActionID   func(childComplexity int) int
		LastCraftActionName func(childComplexity int) int
		PreviousCondition   func(childComplexity int) int
		Progress            func(childComplexity int) int
		ProgressDelta       func(childComplexity int) int
		Quality             func(childComplexity int) int
		QualityDelta        func(childComplexity int) int
		Recipe              func(childComplexity int) int
		ReuseProc           func(childComplexity int) int
		StepNum             func(childComplexity int) int
	}

	Enmity struct {
		NearbyEnemyHate   func(childComplexity int) int
		TargetHateRanking func(childComplexity int) int
	}

	Entity struct {
		BNPCInfo         func(childComplexity int) int
		CastingInfo      func(childComplexity int) int
		ClassJob         func(childComplexity int) int
		ID               func(childComplexity int) int
		Index            func(childComplexity int) int
		IsEnemy          func(childComplexity int) int
		IsNpc            func(childComplexity int) int
		IsPet            func(childComplexity int) int
		LastAction       func(childComplexity int) int
		Level            func(childComplexity int) int
		Location         func(childComplexity int) int
		LockonMarker     func(childComplexity int) int
		Name             func(childComplexity int) int
		OwnerID          func(childComplexity int) int
		RawSpawnJSONData func(childComplexity int) int
		Resources        func(childComplexity int) int
		Statuses         func(childComplexity int) int
		TargetID         func(childComplexity int) int
	}

	EntityEvent struct {
		EntityID func(childComplexity int) int
		StreamID func(childComplexity int) int
		Type     func(childComplexity int) int
	}

	HateEntry struct {
		EnemyID     func(childComplexity int) int
		HatePercent func(childComplexity int) int
	}

	HateRanking struct {
		ActorID func(childComplexity int) int
		Hate    func(childComplexity int) int
	}

	Location struct {
		LastUpdated func(childComplexity int) int
		Orientation func(childComplexity int) int
		X           func(childComplexity int) int
		Y           func(childComplexity int) int
		Z           func(childComplexity int) int
	}

	MapInfo struct {
		ID            func(childComplexity int) int
		Key           func(childComplexity int) int
		OffsetX       func(childComplexity int) int
		OffsetY       func(childComplexity int) int
		PlaceName     func(childComplexity int) int
		PlaceNameSub  func(childComplexity int) int
		SizeFactor    func(childComplexity int) int
		TerritoryType func(childComplexity int) int
	}

	Mutation struct {
		AddPlugin         func(childComplexity int, pluginURL string) int
		CreateAdminToken  func(childComplexity int) int
		RemovePlugin      func(childComplexity int, apiToken string) int
		SendStreamRequest func(childComplexity int, request StreamRequest) int
	}

	NPCInfo struct {
		BaseID  func(childComplexity int) int
		Error   func(childComplexity int) int
		ModelID func(childComplexity int) int
		Name    func(childComplexity int) int
		NameID  func(childComplexity int) int
		Size    func(childComplexity int) int
	}

	Place struct {
		MapID       func(childComplexity int) int
		Maps        func(childComplexity int) int
		TerritoryID func(childComplexity int) int
	}

	Query struct {
		APIVersion func(childComplexity int) int
		Entity     func(childComplexity int, streamID int, entityID uint64) int
		Stream     func(childComplexity int, streamID int) int
		Streams    func(childComplexity int) int
	}

	RecipeInfo struct {
		CanHq       func(childComplexity int) int
		Difficulty  func(childComplexity int) int
		Durability  func(childComplexity int) int
		Element     func(childComplexity int) int
		ID          func(childComplexity int) int
		Name        func(childComplexity int) int
		Quality     func(childComplexity int) int
		RecipeLevel func(childComplexity int) int
	}

	RemoveEntity struct {
		ID func(childComplexity int) int
	}

	RemoveStatus struct {
		Index func(childComplexity int) int
	}

	RemoveStream struct {
		ID func(childComplexity int) int
	}

	Resources struct {
		Hp       func(childComplexity int) int
		LastTick func(childComplexity int) int
		MaxHp    func(childComplexity int) int
		MaxMp    func(childComplexity int) int
		Mp       func(childComplexity int) int
		Tp       func(childComplexity int) int
	}

	SetEntities struct {
		Entities func(childComplexity int) int
	}

	Status struct {
		ActorID     func(childComplexity int) int
		Description func(childComplexity int) int
		Duration    func(childComplexity int) int
		ID          func(childComplexity int) int
		LastTick    func(childComplexity int) int
		Name        func(childComplexity int) int
		Param       func(childComplexity int) int
		StartedTime func(childComplexity int) int
	}

	Stream struct {
		CharacterID  func(childComplexity int) int
		CraftingInfo func(childComplexity int) int
		CurrentWorld func(childComplexity int) int
		Enmity       func(childComplexity int) int
		Entities     func(childComplexity int) int
		HomeWorld    func(childComplexity int) int
		ID           func(childComplexity int) int
		InstanceNum  func(childComplexity int) int
		Place        func(childComplexity int) int
		ServerID     func(childComplexity int) int
	}

	StreamEvent struct {
		StreamID func(childComplexity int) int
		Type     func(childComplexity int) int
	}

	Subscription struct {
		EntityEvent func(childComplexity int) int
		StreamEvent func(childComplexity int) int
	}

	UpdateCastingInfo struct {
		CastingInfo func(childComplexity int) int
	}

	UpdateClass struct {
		ClassJob func(childComplexity int) int
		Level    func(childComplexity int) int
	}

	UpdateCraftingInfo struct {
		CraftingInfo func(childComplexity int) int
	}

	UpdateEnmity struct {
		Enmity func(childComplexity int) int
	}

	UpdateIDs struct {
		CharacterID  func(childComplexity int) int
		CurrentWorld func(childComplexity int) int
		HomeWorld    func(childComplexity int) int
		InstanceNum  func(childComplexity int) int
		ServerID     func(childComplexity int) int
	}

	UpdateLastAction struct {
		Action func(childComplexity int) int
	}

	UpdateLocation struct {
		Location func(childComplexity int) int
	}

	UpdateLockonMarker struct {
		LockonMarker func(childComplexity int) int
	}

	UpdateMap struct {
		Place func(childComplexity int) int
	}

	UpdateResources struct {
		Resources func(childComplexity int) int
	}

	UpdateTarget struct {
		TargetID func(childComplexity int) int
	}

	UpsertStatus struct {
		Index  func(childComplexity int) int
		Status func(childComplexity int) int
	}

	World struct {
		ID   func(childComplexity int) int
		Name func(childComplexity int) int
	}
}

type MutationResolver interface {
	SendStreamRequest(ctx context.Context, request StreamRequest) (string, error)
	CreateAdminToken(ctx context.Context) (string, error)
	AddPlugin(ctx context.Context, pluginURL string) (string, error)
	RemovePlugin(ctx context.Context, apiToken string) (bool, error)
}
type QueryResolver interface {
	APIVersion(ctx context.Context) (string, error)
	Streams(ctx context.Context) ([]Stream, error)
	Stream(ctx context.Context, streamID int) (*Stream, error)
	Entity(ctx context.Context, streamID int, entityID uint64) (*Entity, error)
}
type SubscriptionResolver interface {
	StreamEvent(ctx context.Context) (<-chan *StreamEvent, error)
	EntityEvent(ctx context.Context) (<-chan *EntityEvent, error)
}

type executableSchema struct {
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}

func (e *executableSchema) Schema() *ast.Schema {
	return parsedSchema
}

func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e}
	_ = ec
	switch typeName + "." + field {

	case "Action.animationLockTime":
		if e.complexity.Action.AnimationLockTime == nil {
			break
		}

		return e.complexity.Action.AnimationLockTime(childComplexity), true

	case "Action.effectDisplayType":
		if e.complexity.Action.EffectDisplayType == nil {
			break
		}

		return e.complexity.Action.EffectDisplayType(childComplexity), true

	case "Action.effectFlags":
		if e.complexity.Action.EffectFlags == nil {
			break
		}

		return e.complexity.Action.EffectFlags(childComplexity), true

	case "Action.effects":
		if e.complexity.Action.Effects == nil {
			break
		}

		return e.complexity.Action.Effects(childComplexity), true

	case "Action.globalCounter":
		if e.complexity.Action.GlobalCounter == nil {
			break
		}

		return e.complexity.Action.GlobalCounter(childComplexity), true

	case "Action.hiddenAnimation":
		if e.complexity.Action.HiddenAnimation == nil {
			break
		}

		return e.complexity.Action.HiddenAnimation(childComplexity), true

	case "Action.id":
		if e.complexity.Action.ID == nil {
			break
		}

		return e.complexity.Action.ID(childComplexity), true

	case "Action.isAoE":
		if e.complexity.Action.IsAoE == nil {
			break
		}

		return e.complexity.Action.IsAoE(childComplexity), true

	case "Action.location":
		if e.complexity.Action.Location == nil {
			break
		}

		return e.complexity.Action.Location(childComplexity), true

	case "Action.name":
		if e.complexity.Action.Name == nil {
			break
		}

		return e.complexity.Action.Name(childComplexity), true

	case "Action.targetID":
		if e.complexity.Action.TargetID == nil {
			break
		}

		return e.complexity.Action.TargetID(childComplexity), true

	case "Action.useTime":
		if e.complexity.Action.UseTime == nil {
			break
		}

		return e.complexity.Action.UseTime(childComplexity), true

	case "Action.variation":
		if e.complexity.Action.Variation == nil {
			break
		}

		return e.complexity.Action.Variation(childComplexity), true

	case "ActionEffect.bonusPercent":
		if e.complexity.ActionEffect.BonusPercent == nil {
			break
		}

		return e.complexity.ActionEffect.BonusPercent(childComplexity), true

	case "ActionEffect.flags":
		if e.complexity.ActionEffect.Flags == nil {
			break
		}

		return e.complexity.ActionEffect.Flags(childComplexity), true

	case "ActionEffect.hitSeverity":
		if e.complexity.ActionEffect.HitSeverity == nil {
			break
		}

		return e.complexity.ActionEffect.HitSeverity(childComplexity), true

	case "ActionEffect.param":
		if e.complexity.ActionEffect.Param == nil {
			break
		}

		return e.complexity.ActionEffect.Param(childComplexity), true

	case "ActionEffect.targetID":
		if e.complexity.ActionEffect.TargetID == nil {
			break
		}

		return e.complexity.ActionEffect.TargetID(childComplexity), true

	case "ActionEffect.type":
		if e.complexity.ActionEffect.Type == nil {
			break
		}

		return e.complexity.ActionEffect.Type(childComplexity), true

	case "ActionEffect.value":
		if e.complexity.ActionEffect.Value == nil {
			break
		}

		return e.complexity.ActionEffect.Value(childComplexity), true

	case "ActionEffect.valueMultiplier":
		if e.complexity.ActionEffect.ValueMultiplier == nil {
			break
		}

		return e.complexity.ActionEffect.ValueMultiplier(childComplexity), true

	case "AddEntity.entity":
		if e.complexity.AddEntity.Entity == nil {
			break
		}

		return e.complexity.AddEntity.Entity(childComplexity), true

	case "AddStream.stream":
		if e.complexity.AddStream.Stream == nil {
			break
		}

		return e.complexity.AddStream.Stream(childComplexity), true

	case "CastingInfo.actionID":
		if e.complexity.CastingInfo.ActionID == nil {
			break
		}

		return e.complexity.CastingInfo.ActionID(childComplexity), true

	case "CastingInfo.actionName":
		if e.complexity.CastingInfo.ActionName == nil {
			break
		}

		return e.complexity.CastingInfo.ActionName(childComplexity), true

	case "CastingInfo.castTime":
		if e.complexity.CastingInfo.CastTime == nil {
			break
		}

		return e.complexity.CastingInfo.CastTime(childComplexity), true

	case "CastingInfo.castType":
		if e.complexity.CastingInfo.CastType == nil {
			break
		}

		return e.complexity.CastingInfo.CastType(childComplexity), true

	case "CastingInfo.effectRange":
		if e.complexity.CastingInfo.EffectRange == nil {
			break
		}

		return e.complexity.CastingInfo.EffectRange(childComplexity), true

	case "CastingInfo.location":
		if e.complexity.CastingInfo.Location == nil {
			break
		}

		return e.complexity.CastingInfo.Location(childComplexity), true

	case "CastingInfo.omen":
		if e.complexity.CastingInfo.Omen == nil {
			break
		}

		return e.complexity.CastingInfo.Omen(childComplexity), true

	case "CastingInfo.startTime":
		if e.complexity.CastingInfo.StartTime == nil {
			break
		}

		return e.complexity.CastingInfo.StartTime(childComplexity), true

	case "CastingInfo.targetID":
		if e.complexity.CastingInfo.TargetID == nil {
			break
		}

		return e.complexity.CastingInfo.TargetID(childComplexity), true

	case "CastingInfo.xAxisModifier":
		if e.complexity.CastingInfo.XAxisModifier == nil {
			break
		}

		return e.complexity.CastingInfo.XAxisModifier(childComplexity), true

	case "ChatEvent.channelID":
		if e.complexity.ChatEvent.ChannelID == nil {
			break
		}

		return e.complexity.ChatEvent.ChannelID(childComplexity), true

	case "ChatEvent.channelType":
		if e.complexity.ChatEvent.ChannelType == nil {
			break
		}

		return e.complexity.ChatEvent.ChannelType(childComplexity), true

	case "ChatEvent.channelWorld":
		if e.complexity.ChatEvent.ChannelWorld == nil {
			break
		}

		return e.complexity.ChatEvent.ChannelWorld(childComplexity), true

	case "ChatEvent.contentID":
		if e.complexity.ChatEvent.ContentID == nil {
			break
		}

		return e.complexity.ChatEvent.ContentID(childComplexity), true

	case "ChatEvent.entityID":
		if e.complexity.ChatEvent.EntityID == nil {
			break
		}

		return e.complexity.ChatEvent.EntityID(childComplexity), true

	case "ChatEvent.message":
		if e.complexity.ChatEvent.Message == nil {
			break
		}

		return e.complexity.ChatEvent.Message(childComplexity), true

	case "ChatEvent.name":
		if e.complexity.ChatEvent.Name == nil {
			break
		}

		return e.complexity.ChatEvent.Name(childComplexity), true

	case "ChatEvent.world":
		if e.complexity.ChatEvent.World == nil {
			break
		}

		return e.complexity.ChatEvent.World(childComplexity), true

	case "ClassJob.abbreviation":
		if e.complexity.ClassJob.Abbreviation == nil {
			break
		}

		return e.complexity.ClassJob.Abbreviation(childComplexity), true

	case "ClassJob.id":
		if e.complexity.ClassJob.ID == nil {
			break
		}

		return e.complexity.ClassJob.ID(childComplexity), true

	case "ClassJob.name":
		if e.complexity.ClassJob.Name == nil {
			break
		}

		return e.complexity.ClassJob.Name(childComplexity), true

	case "CraftingInfo.currentCondition":
		if e.complexity.CraftingInfo.CurrentCondition == nil {
			break
		}

		return e.complexity.CraftingInfo.CurrentCondition(childComplexity), true

	case "CraftingInfo.durability":
		if e.complexity.CraftingInfo.Durability == nil {
			break
		}

		return e.complexity.CraftingInfo.Durability(childComplexity), true

	case "CraftingInfo.durabilityDelta":
		if e.complexity.CraftingInfo.DurabilityDelta == nil {
			break
		}

		return e.complexity.CraftingInfo.DurabilityDelta(childComplexity), true

	case "CraftingInfo.hqChance":
		if e.complexity.CraftingInfo.HqChance == nil {
			break
		}

		return e.complexity.CraftingInfo.HqChance(childComplexity), true

	case "CraftingInfo.lastCraftActionID":
		if e.complexity.CraftingInfo.LastCraftActionID == nil {
			break
		}

		return e.complexity.CraftingInfo.LastCraftActionID(childComplexity), true

	case "CraftingInfo.lastCraftActionName":
		if e.complexity.CraftingInfo.LastCraftActionName == nil {
			break
		}

		return e.complexity.CraftingInfo.LastCraftActionName(childComplexity), true

	case "CraftingInfo.previousCondition":
		if e.complexity.CraftingInfo.PreviousCondition == nil {
			break
		}

		return e.complexity.CraftingInfo.PreviousCondition(childComplexity), true

	case "CraftingInfo.progress":
		if e.complexity.CraftingInfo.Progress == nil {
			break
		}

		return e.complexity.CraftingInfo.Progress(childComplexity), true

	case "CraftingInfo.progressDelta":
		if e.complexity.CraftingInfo.ProgressDelta == nil {
			break
		}

		return e.complexity.CraftingInfo.ProgressDelta(childComplexity), true

	case "CraftingInfo.quality":
		if e.complexity.CraftingInfo.Quality == nil {
			break
		}

		return e.complexity.CraftingInfo.Quality(childComplexity), true

	case "CraftingInfo.qualityDelta":
		if e.complexity.CraftingInfo.QualityDelta == nil {
			break
		}

		return e.complexity.CraftingInfo.QualityDelta(childComplexity), true

	case "CraftingInfo.recipe":
		if e.complexity.CraftingInfo.Recipe == nil {
			break
		}

		return e.complexity.CraftingInfo.Recipe(childComplexity), true

	case "CraftingInfo.reuseProc":
		if e.complexity.CraftingInfo.ReuseProc == nil {
			break
		}

		return e.complexity.CraftingInfo.ReuseProc(childComplexity), true

	case "CraftingInfo.stepNum":
		if e.complexity.CraftingInfo.StepNum == nil {
			break
		}

		return e.complexity.CraftingInfo.StepNum(childComplexity), true

	case "Enmity.nearbyEnemyHate":
		if e.complexity.Enmity.NearbyEnemyHate == nil {
			break
		}

		return e.complexity.Enmity.NearbyEnemyHate(childComplexity), true

	case "Enmity.targetHateRanking":
		if e.complexity.Enmity.TargetHateRanking == nil {
			break
		}

		return e.complexity.Enmity.TargetHateRanking(childComplexity), true

	case "Entity.bNPCInfo":
		if e.complexity.Entity.BNPCInfo == nil {
			break
		}

		return e.complexity.Entity.BNPCInfo(childComplexity), true

	case "Entity.castingInfo":
		if e.complexity.Entity.CastingInfo == nil {
			break
		}

		return e.complexity.Entity.CastingInfo(childComplexity), true

	case "Entity.classJob":
		if e.complexity.Entity.ClassJob == nil {
			break
		}

		return e.complexity.Entity.ClassJob(childComplexity), true

	case "Entity.id":
		if e.complexity.Entity.ID == nil {
			break
		}

		return e.complexity.Entity.ID(childComplexity), true

	case "Entity.index":
		if e.complexity.Entity.Index == nil {
			break
		}

		return e.complexity.Entity.Index(childComplexity), true

	case "Entity.isEnemy":
		if e.complexity.Entity.IsEnemy == nil {
			break
		}

		return e.complexity.Entity.IsEnemy(childComplexity), true

	case "Entity.isNPC":
		if e.complexity.Entity.IsNpc == nil {
			break
		}

		return e.complexity.Entity.IsNpc(childComplexity), true

	case "Entity.isPet":
		if e.complexity.Entity.IsPet == nil {
			break
		}

		return e.complexity.Entity.IsPet(childComplexity), true

	case "Entity.lastAction":
		if e.complexity.Entity.LastAction == nil {
			break
		}

		return e.complexity.Entity.LastAction(childComplexity), true

	case "Entity.level":
		if e.complexity.Entity.Level == nil {
			break
		}

		return e.complexity.Entity.Level(childComplexity), true

	case "Entity.location":
		if e.complexity.Entity.Location == nil {
			break
		}

		return e.complexity.Entity.Location(childComplexity), true

	case "Entity.lockonMarker":
		if e.complexity.Entity.LockonMarker == nil {
			break
		}

		return e.complexity.Entity.LockonMarker(childComplexity), true

	case "Entity.name":
		if e.complexity.Entity.Name == nil {
			break
		}

		return e.complexity.Entity.Name(childComplexity), true

	case "Entity.ownerID":
		if e.complexity.Entity.OwnerID == nil {
			break
		}

		return e.complexity.Entity.OwnerID(childComplexity), true

	case "Entity.rawSpawnJSONData":
		if e.complexity.Entity.RawSpawnJSONData == nil {
			break
		}

		return e.complexity.Entity.RawSpawnJSONData(childComplexity), true

	case "Entity.resources":
		if e.complexity.Entity.Resources == nil {
			break
		}

		return e.complexity.Entity.Resources(childComplexity), true

	case "Entity.statuses":
		if e.complexity.Entity.Statuses == nil {
			break
		}

		return e.complexity.Entity.Statuses(childComplexity), true

	case "Entity.targetID":
		if e.complexity.Entity.TargetID == nil {
			break
		}

		return e.complexity.Entity.TargetID(childComplexity), true

	case "EntityEvent.entityID":
		if e.complexity.EntityEvent.EntityID == nil {
			break
		}

		return e.complexity.EntityEvent.EntityID(childComplexity), true

	case "EntityEvent.streamID":
		if e.complexity.EntityEvent.StreamID == nil {
			break
		}

		return e.complexity.EntityEvent.StreamID(childComplexity), true

	case "EntityEvent.type":
		if e.complexity.EntityEvent.Type == nil {
			break
		}

		return e.complexity.EntityEvent.Type(childComplexity), true

	case "HateEntry.enemyID":
		if e.complexity.HateEntry.EnemyID == nil {
			break
		}

		return e.complexity.HateEntry.EnemyID(childComplexity), true

	case "HateEntry.hatePercent":
		if e.complexity.HateEntry.HatePercent == nil {
			break
		}

		return e.complexity.HateEntry.HatePercent(childComplexity), true

	case "HateRanking.actorID":
		if e.complexity.HateRanking.ActorID == nil {
			break
		}

		return e.complexity.HateRanking.ActorID(childComplexity), true

	case "HateRanking.hate":
		if e.complexity.HateRanking.Hate == nil {
			break
		}

		return e.complexity.HateRanking.Hate(childComplexity), true

	case "Location.lastUpdated":
		if e.complexity.Location.LastUpdated == nil {
			break
		}

		return e.complexity.Location.LastUpdated(childComplexity), true

	case "Location.orientation":
		if e.complexity.Location.Orientation == nil {
			break
		}

		return e.complexity.Location.Orientation(childComplexity), true

	case "Location.x":
		if e.complexity.Location.X == nil {
			break
		}

		return e.complexity.Location.X(childComplexity), true

	case "Location.y":
		if e.complexity.Location.Y == nil {
			break
		}

		return e.complexity.Location.Y(childComplexity), true

	case "Location.z":
		if e.complexity.Location.Z == nil {
			break
		}

		return e.complexity.Location.Z(childComplexity), true

	case "MapInfo.id":
		if e.complexity.MapInfo.ID == nil {
			break
		}

		return e.complexity.MapInfo.ID(childComplexity), true

	case "MapInfo.key":
		if e.complexity.MapInfo.Key == nil {
			break
		}

		return e.complexity.MapInfo.Key(childComplexity), true

	case "MapInfo.OffsetX":
		if e.complexity.MapInfo.OffsetX == nil {
			break
		}

		return e.complexity.MapInfo.OffsetX(childComplexity), true

	case "MapInfo.OffsetY":
		if e.complexity.MapInfo.OffsetY == nil {
			break
		}

		return e.complexity.MapInfo.OffsetY(childComplexity), true

	case "MapInfo.PlaceName":
		if e.complexity.MapInfo.PlaceName == nil {
			break
		}

		return e.complexity.MapInfo.PlaceName(childComplexity), true

	case "MapInfo.PlaceNameSub":
		if e.complexity.MapInfo.PlaceNameSub == nil {
			break
		}

		return e.complexity.MapInfo.PlaceNameSub(childComplexity), true

	case "MapInfo.SizeFactor":
		if e.complexity.MapInfo.SizeFactor == nil {
			break
		}

		return e.complexity.MapInfo.SizeFactor(childComplexity), true

	case "MapInfo.TerritoryType":
		if e.complexity.MapInfo.TerritoryType == nil {
			break
		}

		return e.complexity.MapInfo.TerritoryType(childComplexity), true

	case "Mutation.addPlugin":
		if e.complexity.Mutation.AddPlugin == nil {
			break
		}

		args, err := ec.field_Mutation_addPlugin_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.AddPlugin(childComplexity, args["pluginURL"].(string)), true

	case "Mutation.createAdminToken":
		if e.complexity.Mutation.CreateAdminToken == nil {
			break
		}

		return e.complexity.Mutation.CreateAdminToken(childComplexity), true

	case "Mutation.removePlugin":
		if e.complexity.Mutation.RemovePlugin == nil {
			break
		}

		args, err := ec.field_Mutation_removePlugin_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.RemovePlugin(childComplexity, args["apiToken"].(string)), true

	case "Mutation.sendStreamRequest":
		if e.complexity.Mutation.SendStreamRequest == nil {
			break
		}

		args, err := ec.field_Mutation_sendStreamRequest_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.SendStreamRequest(childComplexity, args["request"].(StreamRequest)), true

	case "NPCInfo.baseID":
		if e.complexity.NPCInfo.BaseID == nil {
			break
		}

		return e.complexity.NPCInfo.BaseID(childComplexity), true

	case "NPCInfo.error":
		if e.complexity.NPCInfo.Error == nil {
			break
		}

		return e.complexity.NPCInfo.Error(childComplexity), true

	case "NPCInfo.modelID":
		if e.complexity.NPCInfo.ModelID == nil {
			break
		}

		return e.complexity.NPCInfo.ModelID(childComplexity), true

	case "NPCInfo.name":
		if e.complexity.NPCInfo.Name == nil {
			break
		}

		return e.complexity.NPCInfo.Name(childComplexity), true

	case "NPCInfo.nameID":
		if e.complexity.NPCInfo.NameID == nil {
			break
		}

		return e.complexity.NPCInfo.NameID(childComplexity), true

	case "NPCInfo.size":
		if e.complexity.NPCInfo.Size == nil {
			break
		}

		return e.complexity.NPCInfo.Size(childComplexity), true

	case "Place.mapID":
		if e.complexity.Place.MapID == nil {
			break
		}

		return e.complexity.Place.MapID(childComplexity), true

	case "Place.maps":
		if e.complexity.Place.Maps == nil {
			break
		}

		return e.complexity.Place.Maps(childComplexity), true

	case "Place.territoryID":
		if e.complexity.Place.TerritoryID == nil {
			break
		}

		return e.complexity.Place.TerritoryID(childComplexity), true

	case "Query.apiVersion":
		if e.complexity.Query.APIVersion == nil {
			break
		}

		return e.complexity.Query.APIVersion(childComplexity), true

	case "Query.entity":
		if e.complexity.Query.Entity == nil {
			break
		}

		args, err := ec.field_Query_entity_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Entity(childComplexity, args["streamID"].(int), args["entityID"].(uint64)), true

	case "Query.stream":
		if e.complexity.Query.Stream == nil {
			break
		}

		args, err := ec.field_Query_stream_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Stream(childComplexity, args["streamID"].(int)), true

	case "Query.streams":
		if e.complexity.Query.Streams == nil {
			break
		}

		return e.complexity.Query.Streams(childComplexity), true

	case "RecipeInfo.canHQ":
		if e.complexity.RecipeInfo.CanHq == nil {
			break
		}

		return e.complexity.RecipeInfo.CanHq(childComplexity), true

	case "RecipeInfo.difficulty":
		if e.complexity.RecipeInfo.Difficulty == nil {
			break
		}

		return e.complexity.RecipeInfo.Difficulty(childComplexity), true

	case "RecipeInfo.durability":
		if e.complexity.RecipeInfo.Durability == nil {
			break
		}

		return e.complexity.RecipeInfo.Durability(childComplexity), true

	case "RecipeInfo.element":
		if e.complexity.RecipeInfo.Element == nil {
			break
		}

		return e.complexity.RecipeInfo.Element(childComplexity), true

	case "RecipeInfo.id":
		if e.complexity.RecipeInfo.ID == nil {
			break
		}

		return e.complexity.RecipeInfo.ID(childComplexity), true

	case "RecipeInfo.name":
		if e.complexity.RecipeInfo.Name == nil {
			break
		}

		return e.complexity.RecipeInfo.Name(childComplexity), true

	case "RecipeInfo.quality":
		if e.complexity.RecipeInfo.Quality == nil {
			break
		}

		return e.complexity.RecipeInfo.Quality(childComplexity), true

	case "RecipeInfo.recipeLevel":
		if e.complexity.RecipeInfo.RecipeLevel == nil {
			break
		}

		return e.complexity.RecipeInfo.RecipeLevel(childComplexity), true

	case "RemoveEntity.id":
		if e.complexity.RemoveEntity.ID == nil {
			break
		}

		return e.complexity.RemoveEntity.ID(childComplexity), true

	case "RemoveStatus.index":
		if e.complexity.RemoveStatus.Index == nil {
			break
		}

		return e.complexity.RemoveStatus.Index(childComplexity), true

	case "RemoveStream.id":
		if e.complexity.RemoveStream.ID == nil {
			break
		}

		return e.complexity.RemoveStream.ID(childComplexity), true

	case "Resources.hp":
		if e.complexity.Resources.Hp == nil {
			break
		}

		return e.complexity.Resources.Hp(childComplexity), true

	case "Resources.lastTick":
		if e.complexity.Resources.LastTick == nil {
			break
		}

		return e.complexity.Resources.LastTick(childComplexity), true

	case "Resources.maxHP":
		if e.complexity.Resources.MaxHp == nil {
			break
		}

		return e.complexity.Resources.MaxHp(childComplexity), true

	case "Resources.maxMP":
		if e.complexity.Resources.MaxMp == nil {
			break
		}

		return e.complexity.Resources.MaxMp(childComplexity), true

	case "Resources.mp":
		if e.complexity.Resources.Mp == nil {
			break
		}

		return e.complexity.Resources.Mp(childComplexity), true

	case "Resources.tp":
		if e.complexity.Resources.Tp == nil {
			break
		}

		return e.complexity.Resources.Tp(childComplexity), true

	case "SetEntities.entities":
		if e.complexity.SetEntities.Entities == nil {
			break
		}

		return e.complexity.SetEntities.Entities(childComplexity), true

	case "Status.actorID":
		if e.complexity.Status.ActorID == nil {
			break
		}

		return e.complexity.Status.ActorID(childComplexity), true

	case "Status.description":
		if e.complexity.Status.Description == nil {
			break
		}

		return e.complexity.Status.Description(childComplexity), true

	case "Status.duration":
		if e.complexity.Status.Duration == nil {
			break
		}

		return e.complexity.Status.Duration(childComplexity), true

	case "Status.id":
		if e.complexity.Status.ID == nil {
			break
		}

		return e.complexity.Status.ID(childComplexity), true

	case "Status.lastTick":
		if e.complexity.Status.LastTick == nil {
			break
		}

		return e.complexity.Status.LastTick(childComplexity), true

	case "Status.name":
		if e.complexity.Status.Name == nil {
			break
		}

		return e.complexity.Status.Name(childComplexity), true

	case "Status.param":
		if e.complexity.Status.Param == nil {
			break
		}

		return e.complexity.Status.Param(childComplexity), true

	case "Status.startedTime":
		if e.complexity.Status.StartedTime == nil {
			break
		}

		return e.complexity.Status.StartedTime(childComplexity), true

	case "Stream.characterID":
		if e.complexity.Stream.CharacterID == nil {
			break
		}

		return e.complexity.Stream.CharacterID(childComplexity), true

	case "Stream.craftingInfo":
		if e.complexity.Stream.CraftingInfo == nil {
			break
		}

		return e.complexity.Stream.CraftingInfo(childComplexity), true

	case "Stream.currentWorld":
		if e.complexity.Stream.CurrentWorld == nil {
			break
		}

		return e.complexity.Stream.CurrentWorld(childComplexity), true

	case "Stream.enmity":
		if e.complexity.Stream.Enmity == nil {
			break
		}

		return e.complexity.Stream.Enmity(childComplexity), true

	case "Stream.entities":
		if e.complexity.Stream.Entities == nil {
			break
		}

		return e.complexity.Stream.Entities(childComplexity), true

	case "Stream.homeWorld":
		if e.complexity.Stream.HomeWorld == nil {
			break
		}

		return e.complexity.Stream.HomeWorld(childComplexity), true

	case "Stream.id":
		if e.complexity.Stream.ID == nil {
			break
		}

		return e.complexity.Stream.ID(childComplexity), true

	case "Stream.instanceNum":
		if e.complexity.Stream.InstanceNum == nil {
			break
		}

		return e.complexity.Stream.InstanceNum(childComplexity), true

	case "Stream.place":
		if e.complexity.Stream.Place == nil {
			break
		}

		return e.complexity.Stream.Place(childComplexity), true

	case "Stream.serverID":
		if e.complexity.Stream.ServerID == nil {
			break
		}

		return e.complexity.Stream.ServerID(childComplexity), true

	case "StreamEvent.streamID":
		if e.complexity.StreamEvent.StreamID == nil {
			break
		}

		return e.complexity.StreamEvent.StreamID(childComplexity), true

	case "StreamEvent.type":
		if e.complexity.StreamEvent.Type == nil {
			break
		}

		return e.complexity.StreamEvent.Type(childComplexity), true

	case "Subscription.entityEvent":
		if e.complexity.Subscription.EntityEvent == nil {
			break
		}

		return e.complexity.Subscription.EntityEvent(childComplexity), true

	case "Subscription.streamEvent":
		if e.complexity.Subscription.StreamEvent == nil {
			break
		}

		return e.complexity.Subscription.StreamEvent(childComplexity), true

	case "UpdateCastingInfo.castingInfo":
		if e.complexity.UpdateCastingInfo.CastingInfo == nil {
			break
		}

		return e.complexity.UpdateCastingInfo.CastingInfo(childComplexity), true

	case "UpdateClass.classJob":
		if e.complexity.UpdateClass.ClassJob == nil {
			break
		}

		return e.complexity.UpdateClass.ClassJob(childComplexity), true

	case "UpdateClass.level":
		if e.complexity.UpdateClass.Level == nil {
			break
		}

		return e.complexity.UpdateClass.Level(childComplexity), true

	case "UpdateCraftingInfo.craftingInfo":
		if e.complexity.UpdateCraftingInfo.CraftingInfo == nil {
			break
		}

		return e.complexity.UpdateCraftingInfo.CraftingInfo(childComplexity), true

	case "UpdateEnmity.enmity":
		if e.complexity.UpdateEnmity.Enmity == nil {
			break
		}

		return e.complexity.UpdateEnmity.Enmity(childComplexity), true

	case "UpdateIDs.characterID":
		if e.complexity.UpdateIDs.CharacterID == nil {
			break
		}

		return e.complexity.UpdateIDs.CharacterID(childComplexity), true

	case "UpdateIDs.currentWorld":
		if e.complexity.UpdateIDs.CurrentWorld == nil {
			break
		}

		return e.complexity.UpdateIDs.CurrentWorld(childComplexity), true

	case "UpdateIDs.homeWorld":
		if e.complexity.UpdateIDs.HomeWorld == nil {
			break
		}

		return e.complexity.UpdateIDs.HomeWorld(childComplexity), true

	case "UpdateIDs.instanceNum":
		if e.complexity.UpdateIDs.InstanceNum == nil {
			break
		}

		return e.complexity.UpdateIDs.InstanceNum(childComplexity), true

	case "UpdateIDs.serverID":
		if e.complexity.UpdateIDs.ServerID == nil {
			break
		}

		return e.complexity.UpdateIDs.ServerID(childComplexity), true

	case "UpdateLastAction.action":
		if e.complexity.UpdateLastAction.Action == nil {
			break
		}

		return e.complexity.UpdateLastAction.Action(childComplexity), true

	case "UpdateLocation.location":
		if e.complexity.UpdateLocation.Location == nil {
			break
		}

		return e.complexity.UpdateLocation.Location(childComplexity), true

	case "UpdateLockonMarker.lockonMarker":
		if e.complexity.UpdateLockonMarker.LockonMarker == nil {
			break
		}

		return e.complexity.UpdateLockonMarker.LockonMarker(childComplexity), true

	case "UpdateMap.place":
		if e.complexity.UpdateMap.Place == nil {
			break
		}

		return e.complexity.UpdateMap.Place(childComplexity), true

	case "UpdateResources.resources":
		if e.complexity.UpdateResources.Resources == nil {
			break
		}

		return e.complexity.UpdateResources.Resources(childComplexity), true

	case "UpdateTarget.targetID":
		if e.complexity.UpdateTarget.TargetID == nil {
			break
		}

		return e.complexity.UpdateTarget.TargetID(childComplexity), true

	case "UpsertStatus.index":
		if e.complexity.UpsertStatus.Index == nil {
			break
		}

		return e.complexity.UpsertStatus.Index(childComplexity), true

	case "UpsertStatus.status":
		if e.complexity.UpsertStatus.Status == nil {
			break
		}

		return e.complexity.UpsertStatus.Status(childComplexity), true

	case "World.id":
		if e.complexity.World.ID == nil {
			break
		}

		return e.complexity.World.ID(childComplexity), true

	case "World.name":
		if e.complexity.World.Name == nil {
			break
		}

		return e.complexity.World.Name(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e}
	first := true

	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Query(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

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

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}
	case ast.Subscription:
		next := ec._Subscription(ctx, rc.Operation.SelectionSet)

		var buf bytes.Buffer
		return func(ctx context.Context) *graphql.Response {
			buf.Reset()
			data := next()

			if data == nil {
				return nil
			}
			data.MarshalGQL(&buf)

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

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

type executionContext struct {
	*graphql.OperationContext
	*executableSchema
}

func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(parsedSchema), nil
}

func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
}

var sources = []*ast.Source{
	&ast.Source{Name: "models/schema.graphql", Input: `type Query {
  apiVersion: ID!
  streams: [Stream!]!
  stream(streamID: Int!): Stream!
  entity(streamID: Int!, entityID: Uint!): Entity!
}

type Stream {
  id: Int!
  serverID: Int!
  instanceNum: Int!

  characterID: Uint!
  homeWorld: World!
  currentWorld: World!

  place: Place!
  enmity: Enmity!
  craftingInfo: CraftingInfo

  entities: [Entity!]!
}

type Place {
  mapID: Int!
  territoryID: Int!
  maps: [MapInfo!]!
}

type MapInfo {
  key: Int!
  id: ID!
  SizeFactor: Int!
  OffsetX: Int!
  OffsetY: Int!
  PlaceName: String!
  PlaceNameSub: String!
  TerritoryType: String!
}

type Enmity {
  targetHateRanking: [HateRanking!]!
  nearbyEnemyHate: [HateEntry!]!
}

type Entity {
  id: Uint!
  index: Int!
  name: String!
  targetID: Uint!
  ownerID: Uint!
  level: Int!
  classJob: ClassJob!
  isNPC: Boolean!
  isEnemy: Boolean!
  isPet: Boolean!
  bNPCInfo: NPCInfo
  resources: Resources!
  location: Location!
  lastAction: Action
  statuses: [Status]!
  lockonMarker: Int!

  castingInfo: CastingInfo

  rawSpawnJSONData: String!
}

type HateRanking {
  actorID: Uint!
  hate: Int!
}

type HateEntry {
  enemyID: Uint!
  hatePercent: Int!
}

type NPCInfo {
  nameID: Int!
  baseID: Int!
  modelID: Int!
  name: String
  size: Float
  error: Int!
}

type ClassJob {
  id: Int!
  name: String!
  abbreviation: String!
}

type Resources {
  hp: Int!
  mp: Int!
  tp: Int!
  maxHP: Int!
  maxMP: Int!
  lastTick: Timestamp!
}

type Location {
  x: Float!
  y: Float!
  z: Float!
  orientation: Float!
  lastUpdated: Timestamp!
}

type Action {
  targetID: Uint!
  name: String!
  globalCounter: Int!
  animationLockTime: Float!
  hiddenAnimation: Int!
  location: Location!
  id: Int!
  variation: Int!
  effectDisplayType: Int!
  isAoE: Boolean!
  effects: [ActionEffect!]!
  effectFlags: Int!
  useTime: Timestamp!
}

type ActionEffect {
  targetID: Uint!
  type: Int!
  hitSeverity: Int!
  param: Int!
  bonusPercent: Int!
  valueMultiplier: Int!
  flags: Int!
  value: Int!
}

type Status {
  id: Int!
  param: Int!
  name: String!
  description: String!
  startedTime: Timestamp!
  duration: Timestamp!
  actorID: Uint!
  lastTick: Timestamp!
}

type CastingInfo {
  actionID: Int!
  actionName: String!
  startTime: Timestamp!
  castTime: Timestamp!
  targetID: Uint!
  location: Location!

  castType: Int!
  effectRange: Int!
  xAxisModifier: Int!
  omen: String!
}

type CraftingInfo {
  recipe: RecipeInfo!

  lastCraftActionID: Int!
  lastCraftActionName: String!
  stepNum: Int!

  progress: Int!
  progressDelta: Int!

  quality: Int!
  qualityDelta: Int!

  hqChance: Int!

  durability: Int!
  durabilityDelta: Int!

  currentCondition: Int!
  previousCondition: Int!

  reuseProc: Boolean!
}

type RecipeInfo {
  id: Int!
  name: String!
  recipeLevel: Int!
  element: Int!
  canHQ: Boolean!
  difficulty: Int!
  quality: Int!
  durability: Int!
}

type World {
  id: Int!
  name: String!
}

type Subscription {
  streamEvent: StreamEvent!
  entityEvent: EntityEvent!
}

type StreamEvent {
  streamID: Int!
  type: StreamEventType!
}

union StreamEventType =
  AddStream |
  RemoveStream |
  UpdateIDs |
  UpdateMap |
  UpdateCraftingInfo |
  UpdateEnmity |
  ChatEvent

type AddStream {
  stream: Stream!
}

type RemoveStream {
  id: Int!
}

type UpdateIDs {
  serverID: Int!
  instanceNum: Int!

  characterID: Uint!
  homeWorld: World!
  currentWorld: World!
}

type UpdateMap {
  place: Place!
}

type UpdateCraftingInfo {
  craftingInfo: CraftingInfo
}

type UpdateEnmity {
  enmity: Enmity!
}

type ChatEvent {
  channelID: Uint!
  channelWorld: World!
  channelType: String!

  contentID: Uint!
  entityID: Uint!
  world: World!
  name: String!

  message: String!
}

type EntityEvent {
  streamID: Int!
  entityID: Uint!
  type: EntityEventType!
}

union EntityEventType =
  AddEntity |
  RemoveEntity |
  SetEntities |
  UpdateTarget |
  UpdateClass |
  UpdateLastAction |
  UpdateCastingInfo |
  UpsertStatus |
  RemoveStatus |
  UpdateLocation |
  UpdateResources |
  UpdateLockonMarker

type AddEntity {
  entity: Entity!
}

type RemoveEntity {
  id: Uint!
}

type SetEntities {
  entities: [Entity!]!
}

type UpdateTarget {
  targetID: Uint!
}

type UpdateClass {
  classJob: ClassJob!
  level: Int!
}

type UpdateLastAction {
  action: Action!
}

type UpdateCastingInfo {
  castingInfo: CastingInfo
}

type UpsertStatus {
  index: Int!
  status: Status!
}

type RemoveStatus {
  index: Int!
}

type UpdateLocation {
  location: Location!
}

type UpdateResources {
  resources: Resources!
}

type UpdateLockonMarker {
  lockonMarker: Int!
}

scalar Timestamp
scalar Uint

type Mutation {
  sendStreamRequest(request: StreamRequest!): String!

  createAdminToken: String!
  addPlugin(pluginURL: String!): String!
  removePlugin(apiToken: String!): Boolean!
}

input StreamRequest {
  streamID: Int!
  data: String!
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

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

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

func (ec *executionContext) field_Mutation_addPlugin_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["pluginURL"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["pluginURL"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_removePlugin_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["apiToken"]; ok {
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["apiToken"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_sendStreamRequest_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 StreamRequest
	if tmp, ok := rawArgs["request"]; ok {
		arg0, err = ec.unmarshalNStreamRequest2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamRequest(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["request"] = arg0
	return args, nil
}

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

func (ec *executionContext) field_Query_entity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["streamID"]; ok {
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["streamID"] = arg0
	var arg1 uint64
	if tmp, ok := rawArgs["entityID"]; ok {
		arg1, err = ec.unmarshalNUint2uint64(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["entityID"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query_stream_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 int
	if tmp, ok := rawArgs["streamID"]; ok {
		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["streamID"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		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]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

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

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

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

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

func (ec *executionContext) _Action_targetID(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_name(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_globalCounter(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.GlobalCounter, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_animationLockTime(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AnimationLockTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_hiddenAnimation(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HiddenAnimation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_location(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Location, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Location)
	fc.Result = res
	return ec.marshalNLocation2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_id(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_variation(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Variation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_effectDisplayType(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EffectDisplayType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_isAoE(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsAoE, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_effects(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Effects, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]ActionEffect)
	fc.Result = res
	return ec.marshalNActionEffect2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐActionEffectᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_effectFlags(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EffectFlags, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Action_useTime(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Action",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UseTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_targetID(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_type(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_hitSeverity(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HitSeverity, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_param(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Param, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_bonusPercent(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BonusPercent, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_valueMultiplier(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ValueMultiplier, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_flags(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Flags, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ActionEffect_value(ctx context.Context, field graphql.CollectedField, obj *ActionEffect) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ActionEffect",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Value, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _AddEntity_entity(ctx context.Context, field graphql.CollectedField, obj *AddEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "AddEntity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Entity, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Entity)
	fc.Result = res
	return ec.marshalNEntity2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _AddStream_stream(ctx context.Context, field graphql.CollectedField, obj *AddStream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "AddStream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Stream, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Stream)
	fc.Result = res
	return ec.marshalNStream2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStream(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_actionID(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActionID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_actionName(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActionName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_startTime(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StartTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_castTime(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CastTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_targetID(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_location(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Location, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Location)
	fc.Result = res
	return ec.marshalNLocation2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_castType(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CastType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_effectRange(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EffectRange, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_xAxisModifier(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XAxisModifier, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CastingInfo_omen(ctx context.Context, field graphql.CollectedField, obj *CastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Omen, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_channelID(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ChannelID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_channelWorld(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ChannelWorld, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*World)
	fc.Result = res
	return ec.marshalNWorld2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_channelType(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ChannelType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_contentID(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ContentID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_entityID(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EntityID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_world(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.World, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*World)
	fc.Result = res
	return ec.marshalNWorld2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_name(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ChatEvent_message(ctx context.Context, field graphql.CollectedField, obj *ChatEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ChatEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Message, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ClassJob_id(ctx context.Context, field graphql.CollectedField, obj *ClassJob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ClassJob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _ClassJob_name(ctx context.Context, field graphql.CollectedField, obj *ClassJob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ClassJob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _ClassJob_abbreviation(ctx context.Context, field graphql.CollectedField, obj *ClassJob) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "ClassJob",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Abbreviation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_recipe(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Recipe, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*RecipeInfo)
	fc.Result = res
	return ec.marshalNRecipeInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐRecipeInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_lastCraftActionID(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastCraftActionID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_lastCraftActionName(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastCraftActionName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_stepNum(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StepNum, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_progress(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Progress, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_progressDelta(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ProgressDelta, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_quality(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Quality, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_qualityDelta(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.QualityDelta, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_hqChance(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HqChance, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_durability(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Durability, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_durabilityDelta(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DurabilityDelta, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_currentCondition(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CurrentCondition, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_previousCondition(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PreviousCondition, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _CraftingInfo_reuseProc(ctx context.Context, field graphql.CollectedField, obj *CraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "CraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ReuseProc, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Enmity_targetHateRanking(ctx context.Context, field graphql.CollectedField, obj *Enmity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Enmity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetHateRanking, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]HateRanking)
	fc.Result = res
	return ec.marshalNHateRanking2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateRankingᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Enmity_nearbyEnemyHate(ctx context.Context, field graphql.CollectedField, obj *Enmity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Enmity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NearbyEnemyHate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]HateEntry)
	fc.Result = res
	return ec.marshalNHateEntry2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateEntryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_id(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_index(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Index, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_name(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_targetID(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_ownerID(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OwnerID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_level(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Level, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_classJob(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClassJob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*ClassJob)
	fc.Result = res
	return ec.marshalNClassJob2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐClassJob(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_isNPC(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsNpc, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_isEnemy(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsEnemy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_isPet(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsPet, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_bNPCInfo(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BNPCInfo, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*NPCInfo)
	fc.Result = res
	return ec.marshalONPCInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐNPCInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_resources(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resources, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Resources)
	fc.Result = res
	return ec.marshalNResources2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐResources(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_location(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Location, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Location)
	fc.Result = res
	return ec.marshalNLocation2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_lastAction(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastAction, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Action)
	fc.Result = res
	return ec.marshalOAction2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_statuses(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Statuses, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Status)
	fc.Result = res
	return ec.marshalNStatus2ᚕᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_lockonMarker(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LockonMarker, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_castingInfo(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CastingInfo, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CastingInfo)
	fc.Result = res
	return ec.marshalOCastingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCastingInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _Entity_rawSpawnJSONData(ctx context.Context, field graphql.CollectedField, obj *Entity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Entity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RawSpawnJSONData, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _EntityEvent_streamID(ctx context.Context, field graphql.CollectedField, obj *EntityEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "EntityEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StreamID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _EntityEvent_entityID(ctx context.Context, field graphql.CollectedField, obj *EntityEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "EntityEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EntityID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _EntityEvent_type(ctx context.Context, field graphql.CollectedField, obj *EntityEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "EntityEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(EntityEventType)
	fc.Result = res
	return ec.marshalNEntityEventType2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityEventType(ctx, field.Selections, res)
}

func (ec *executionContext) _HateEntry_enemyID(ctx context.Context, field graphql.CollectedField, obj *HateEntry) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HateEntry",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnemyID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _HateEntry_hatePercent(ctx context.Context, field graphql.CollectedField, obj *HateEntry) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HateEntry",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HatePercent, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _HateRanking_actorID(ctx context.Context, field graphql.CollectedField, obj *HateRanking) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HateRanking",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActorID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _HateRanking_hate(ctx context.Context, field graphql.CollectedField, obj *HateRanking) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "HateRanking",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Hate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Location_x(ctx context.Context, field graphql.CollectedField, obj *Location) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Location",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.X, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Location_y(ctx context.Context, field graphql.CollectedField, obj *Location) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Location",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Y, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Location_z(ctx context.Context, field graphql.CollectedField, obj *Location) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Location",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Z, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Location_orientation(ctx context.Context, field graphql.CollectedField, obj *Location) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Location",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Orientation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(float64)
	fc.Result = res
	return ec.marshalNFloat2float64(ctx, field.Selections, res)
}

func (ec *executionContext) _Location_lastUpdated(ctx context.Context, field graphql.CollectedField, obj *Location) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Location",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastUpdated, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_key(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_id(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_SizeFactor(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SizeFactor, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_OffsetX(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OffsetX, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_OffsetY(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OffsetY, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_PlaceName(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PlaceName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_PlaceNameSub(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PlaceNameSub, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _MapInfo_TerritoryType(ctx context.Context, field graphql.CollectedField, obj *MapInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "MapInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TerritoryType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_sendStreamRequest(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_sendStreamRequest_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().SendStreamRequest(rctx, args["request"].(StreamRequest))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createAdminToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreateAdminToken(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_addPlugin(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_addPlugin_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().AddPlugin(rctx, args["pluginURL"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_removePlugin(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Mutation",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_removePlugin_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().RemovePlugin(rctx, args["apiToken"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_nameID(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.NameID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_baseID(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.BaseID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_modelID(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ModelID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_name(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_size(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Size, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*float64)
	fc.Result = res
	return ec.marshalOFloat2ᚖfloat64(ctx, field.Selections, res)
}

func (ec *executionContext) _NPCInfo_error(ctx context.Context, field graphql.CollectedField, obj *NPCInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "NPCInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Error, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Place_mapID(ctx context.Context, field graphql.CollectedField, obj *Place) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Place",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MapID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Place_territoryID(ctx context.Context, field graphql.CollectedField, obj *Place) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Place",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TerritoryID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Place_maps(ctx context.Context, field graphql.CollectedField, obj *Place) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Place",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Maps, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]MapInfo)
	fc.Result = res
	return ec.marshalNMapInfo2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐMapInfoᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_apiVersion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().APIVersion(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_streams(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Streams(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]Stream)
	fc.Result = res
	return ec.marshalNStream2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_stream(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_stream_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Stream(rctx, args["streamID"].(int))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Stream)
	fc.Result = res
	return ec.marshalNStream2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStream(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_entity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_entity_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Entity(rctx, args["streamID"].(int), args["entityID"].(uint64))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Entity)
	fc.Result = res
	return ec.marshalNEntity2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query___type_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(args["name"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Query",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectSchema()
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Schema)
	fc.Result = res
	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_id(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_name(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_recipeLevel(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.RecipeLevel, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_element(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Element, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_canHQ(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CanHq, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_difficulty(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Difficulty, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_quality(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Quality, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RecipeInfo_durability(ctx context.Context, field graphql.CollectedField, obj *RecipeInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RecipeInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Durability, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RemoveEntity_id(ctx context.Context, field graphql.CollectedField, obj *RemoveEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RemoveEntity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _RemoveStatus_index(ctx context.Context, field graphql.CollectedField, obj *RemoveStatus) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RemoveStatus",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Index, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _RemoveStream_id(ctx context.Context, field graphql.CollectedField, obj *RemoveStream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "RemoveStream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_hp(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Hp, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_mp(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Mp, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_tp(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Tp, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_maxHP(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MaxHp, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_maxMP(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MaxMp, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Resources_lastTick(ctx context.Context, field graphql.CollectedField, obj *Resources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Resources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastTick, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _SetEntities_entities(ctx context.Context, field graphql.CollectedField, obj *SetEntities) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "SetEntities",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Entities, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]Entity)
	fc.Result = res
	return ec.marshalNEntity2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_id(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_param(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Param, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_name(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_description(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_startedTime(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StartedTime, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_duration(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Duration, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_actorID(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActorID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Status_lastTick(ctx context.Context, field graphql.CollectedField, obj *Status) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Status",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastTick, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTimestamp2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_id(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_serverID(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ServerID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_instanceNum(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InstanceNum, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_characterID(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CharacterID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_homeWorld(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HomeWorld, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(World)
	fc.Result = res
	return ec.marshalNWorld2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_currentWorld(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CurrentWorld, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(World)
	fc.Result = res
	return ec.marshalNWorld2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_place(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Place, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(Place)
	fc.Result = res
	return ec.marshalNPlace2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐPlace(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_enmity(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Enmity, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(Enmity)
	fc.Result = res
	return ec.marshalNEnmity2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEnmity(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_craftingInfo(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CraftingInfo, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CraftingInfo)
	fc.Result = res
	return ec.marshalOCraftingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCraftingInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _Stream_entities(ctx context.Context, field graphql.CollectedField, obj *Stream) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Stream",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Entities(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]Entity)
	fc.Result = res
	return ec.marshalNEntity2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _StreamEvent_streamID(ctx context.Context, field graphql.CollectedField, obj *StreamEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "StreamEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StreamID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _StreamEvent_type(ctx context.Context, field graphql.CollectedField, obj *StreamEvent) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "StreamEvent",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(StreamEventType)
	fc.Result = res
	return ec.marshalNStreamEventType2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamEventType(ctx, field.Selections, res)
}

func (ec *executionContext) _Subscription_streamEvent(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = nil
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Subscription",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Subscription().StreamEvent(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return nil
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return nil
	}
	return func() graphql.Marshaler {
		res, ok := <-resTmp.(<-chan *StreamEvent)
		if !ok {
			return nil
		}
		return graphql.WriterFunc(func(w io.Writer) {
			w.Write([]byte{'{'})
			graphql.MarshalString(field.Alias).MarshalGQL(w)
			w.Write([]byte{':'})
			ec.marshalNStreamEvent2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamEvent(ctx, field.Selections, res).MarshalGQL(w)
			w.Write([]byte{'}'})
		})
	}
}

func (ec *executionContext) _Subscription_entityEvent(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = nil
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "Subscription",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Subscription().EntityEvent(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return nil
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return nil
	}
	return func() graphql.Marshaler {
		res, ok := <-resTmp.(<-chan *EntityEvent)
		if !ok {
			return nil
		}
		return graphql.WriterFunc(func(w io.Writer) {
			w.Write([]byte{'{'})
			graphql.MarshalString(field.Alias).MarshalGQL(w)
			w.Write([]byte{':'})
			ec.marshalNEntityEvent2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityEvent(ctx, field.Selections, res).MarshalGQL(w)
			w.Write([]byte{'}'})
		})
	}
}

func (ec *executionContext) _UpdateCastingInfo_castingInfo(ctx context.Context, field graphql.CollectedField, obj *UpdateCastingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateCastingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CastingInfo, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CastingInfo)
	fc.Result = res
	return ec.marshalOCastingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCastingInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateClass_classJob(ctx context.Context, field graphql.CollectedField, obj *UpdateClass) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateClass",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClassJob, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*ClassJob)
	fc.Result = res
	return ec.marshalNClassJob2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐClassJob(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateClass_level(ctx context.Context, field graphql.CollectedField, obj *UpdateClass) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateClass",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Level, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateCraftingInfo_craftingInfo(ctx context.Context, field graphql.CollectedField, obj *UpdateCraftingInfo) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateCraftingInfo",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CraftingInfo, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CraftingInfo)
	fc.Result = res
	return ec.marshalOCraftingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCraftingInfo(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateEnmity_enmity(ctx context.Context, field graphql.CollectedField, obj *UpdateEnmity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateEnmity",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Enmity, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Enmity)
	fc.Result = res
	return ec.marshalNEnmity2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEnmity(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateIDs_serverID(ctx context.Context, field graphql.CollectedField, obj *UpdateIDs) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateIDs",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ServerID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateIDs_instanceNum(ctx context.Context, field graphql.CollectedField, obj *UpdateIDs) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateIDs",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InstanceNum, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateIDs_characterID(ctx context.Context, field graphql.CollectedField, obj *UpdateIDs) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateIDs",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CharacterID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateIDs_homeWorld(ctx context.Context, field graphql.CollectedField, obj *UpdateIDs) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateIDs",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.HomeWorld, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*World)
	fc.Result = res
	return ec.marshalNWorld2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateIDs_currentWorld(ctx context.Context, field graphql.CollectedField, obj *UpdateIDs) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateIDs",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CurrentWorld, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*World)
	fc.Result = res
	return ec.marshalNWorld2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateLastAction_action(ctx context.Context, field graphql.CollectedField, obj *UpdateLastAction) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateLastAction",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Action)
	fc.Result = res
	return ec.marshalNAction2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateLocation_location(ctx context.Context, field graphql.CollectedField, obj *UpdateLocation) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateLocation",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Location, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Location)
	fc.Result = res
	return ec.marshalNLocation2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateLockonMarker_lockonMarker(ctx context.Context, field graphql.CollectedField, obj *UpdateLockonMarker) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateLockonMarker",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LockonMarker, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateMap_place(ctx context.Context, field graphql.CollectedField, obj *UpdateMap) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateMap",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Place, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Place)
	fc.Result = res
	return ec.marshalNPlace2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐPlace(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateResources_resources(ctx context.Context, field graphql.CollectedField, obj *UpdateResources) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateResources",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resources, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Resources)
	fc.Result = res
	return ec.marshalNResources2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐResources(ctx, field.Selections, res)
}

func (ec *executionContext) _UpdateTarget_targetID(ctx context.Context, field graphql.CollectedField, obj *UpdateTarget) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpdateTarget",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.TargetID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(uint64)
	fc.Result = res
	return ec.marshalNUint2uint64(ctx, field.Selections, res)
}

func (ec *executionContext) _UpsertStatus_index(ctx context.Context, field graphql.CollectedField, obj *UpsertStatus) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpsertStatus",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Index, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _UpsertStatus_status(ctx context.Context, field graphql.CollectedField, obj *UpsertStatus) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "UpsertStatus",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Status, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Status)
	fc.Result = res
	return ec.marshalNStatus2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx, field.Selections, res)
}

func (ec *executionContext) _World_id(ctx context.Context, field graphql.CollectedField, obj *World) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "World",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _World_name(ctx context.Context, field graphql.CollectedField, obj *World) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "World",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Locations, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Directive",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__EnumValue",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Field",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__InputValue",
		Field:    field,
		Args:     nil,
		IsMethod: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefaultValue, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Types(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.QueryType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MutationType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SubscriptionType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Schema",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Directives(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Directive)
	fc.Result = res
	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Kind(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_fields_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fields(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Field)
	fc.Result = res
	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Interfaces(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PossibleTypes(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.EnumValue)
	fc.Result = res
	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InputFields(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:   "__Type",
		Field:    field,
		Args:     nil,
		IsMethod: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OfType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

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

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

func (ec *executionContext) unmarshalInputStreamRequest(ctx context.Context, obj interface{}) (StreamRequest, error) {
	var it StreamRequest
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "streamID":
			var err error
			it.StreamID, err = ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
		case "data":
			var err error
			it.Data, err = ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

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

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

func (ec *executionContext) _EntityEventType(ctx context.Context, sel ast.SelectionSet, obj EntityEventType) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case AddEntity:
		return ec._AddEntity(ctx, sel, &obj)
	case *AddEntity:
		if obj == nil {
			return graphql.Null
		}
		return ec._AddEntity(ctx, sel, obj)
	case RemoveEntity:
		return ec._RemoveEntity(ctx, sel, &obj)
	case *RemoveEntity:
		if obj == nil {
			return graphql.Null
		}
		return ec._RemoveEntity(ctx, sel, obj)
	case SetEntities:
		return ec._SetEntities(ctx, sel, &obj)
	case *SetEntities:
		if obj == nil {
			return graphql.Null
		}
		return ec._SetEntities(ctx, sel, obj)
	case UpdateTarget:
		return ec._UpdateTarget(ctx, sel, &obj)
	case *UpdateTarget:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateTarget(ctx, sel, obj)
	case UpdateClass:
		return ec._UpdateClass(ctx, sel, &obj)
	case *UpdateClass:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateClass(ctx, sel, obj)
	case UpdateLastAction:
		return ec._UpdateLastAction(ctx, sel, &obj)
	case *UpdateLastAction:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateLastAction(ctx, sel, obj)
	case UpdateCastingInfo:
		return ec._UpdateCastingInfo(ctx, sel, &obj)
	case *UpdateCastingInfo:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateCastingInfo(ctx, sel, obj)
	case UpsertStatus:
		return ec._UpsertStatus(ctx, sel, &obj)
	case *UpsertStatus:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpsertStatus(ctx, sel, obj)
	case RemoveStatus:
		return ec._RemoveStatus(ctx, sel, &obj)
	case *RemoveStatus:
		if obj == nil {
			return graphql.Null
		}
		return ec._RemoveStatus(ctx, sel, obj)
	case UpdateLocation:
		return ec._UpdateLocation(ctx, sel, &obj)
	case *UpdateLocation:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateLocation(ctx, sel, obj)
	case UpdateResources:
		return ec._UpdateResources(ctx, sel, &obj)
	case *UpdateResources:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateResources(ctx, sel, obj)
	case UpdateLockonMarker:
		return ec._UpdateLockonMarker(ctx, sel, &obj)
	case *UpdateLockonMarker:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateLockonMarker(ctx, sel, obj)
	default:
		panic(fmt.Errorf("unexpected type %T", obj))
	}
}

func (ec *executionContext) _StreamEventType(ctx context.Context, sel ast.SelectionSet, obj StreamEventType) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case AddStream:
		return ec._AddStream(ctx, sel, &obj)
	case *AddStream:
		if obj == nil {
			return graphql.Null
		}
		return ec._AddStream(ctx, sel, obj)
	case RemoveStream:
		return ec._RemoveStream(ctx, sel, &obj)
	case *RemoveStream:
		if obj == nil {
			return graphql.Null
		}
		return ec._RemoveStream(ctx, sel, obj)
	case UpdateIDs:
		return ec._UpdateIDs(ctx, sel, &obj)
	case *UpdateIDs:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateIDs(ctx, sel, obj)
	case UpdateMap:
		return ec._UpdateMap(ctx, sel, &obj)
	case *UpdateMap:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateMap(ctx, sel, obj)
	case UpdateCraftingInfo:
		return ec._UpdateCraftingInfo(ctx, sel, &obj)
	case *UpdateCraftingInfo:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateCraftingInfo(ctx, sel, obj)
	case UpdateEnmity:
		return ec._UpdateEnmity(ctx, sel, &obj)
	case *UpdateEnmity:
		if obj == nil {
			return graphql.Null
		}
		return ec._UpdateEnmity(ctx, sel, obj)
	case ChatEvent:
		return ec._ChatEvent(ctx, sel, &obj)
	case *ChatEvent:
		if obj == nil {
			return graphql.Null
		}
		return ec._ChatEvent(ctx, sel, obj)
	default:
		panic(fmt.Errorf("unexpected type %T", obj))
	}
}

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

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

var actionImplementors = []string{"Action"}

func (ec *executionContext) _Action(ctx context.Context, sel ast.SelectionSet, obj *Action) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, actionImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Action")
		case "targetID":
			out.Values[i] = ec._Action_targetID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._Action_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "globalCounter":
			out.Values[i] = ec._Action_globalCounter(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "animationLockTime":
			out.Values[i] = ec._Action_animationLockTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hiddenAnimation":
			out.Values[i] = ec._Action_hiddenAnimation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "location":
			out.Values[i] = ec._Action_location(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "id":
			out.Values[i] = ec._Action_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "variation":
			out.Values[i] = ec._Action_variation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "effectDisplayType":
			out.Values[i] = ec._Action_effectDisplayType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isAoE":
			out.Values[i] = ec._Action_isAoE(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "effects":
			out.Values[i] = ec._Action_effects(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "effectFlags":
			out.Values[i] = ec._Action_effectFlags(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "useTime":
			out.Values[i] = ec._Action_useTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var actionEffectImplementors = []string{"ActionEffect"}

func (ec *executionContext) _ActionEffect(ctx context.Context, sel ast.SelectionSet, obj *ActionEffect) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, actionEffectImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ActionEffect")
		case "targetID":
			out.Values[i] = ec._ActionEffect_targetID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec._ActionEffect_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hitSeverity":
			out.Values[i] = ec._ActionEffect_hitSeverity(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "param":
			out.Values[i] = ec._ActionEffect_param(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bonusPercent":
			out.Values[i] = ec._ActionEffect_bonusPercent(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "valueMultiplier":
			out.Values[i] = ec._ActionEffect_valueMultiplier(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "flags":
			out.Values[i] = ec._ActionEffect_flags(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "value":
			out.Values[i] = ec._ActionEffect_value(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var addEntityImplementors = []string{"AddEntity", "EntityEventType"}

func (ec *executionContext) _AddEntity(ctx context.Context, sel ast.SelectionSet, obj *AddEntity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, addEntityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("AddEntity")
		case "entity":
			out.Values[i] = ec._AddEntity_entity(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var addStreamImplementors = []string{"AddStream", "StreamEventType"}

func (ec *executionContext) _AddStream(ctx context.Context, sel ast.SelectionSet, obj *AddStream) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, addStreamImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("AddStream")
		case "stream":
			out.Values[i] = ec._AddStream_stream(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var castingInfoImplementors = []string{"CastingInfo"}

func (ec *executionContext) _CastingInfo(ctx context.Context, sel ast.SelectionSet, obj *CastingInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, castingInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CastingInfo")
		case "actionID":
			out.Values[i] = ec._CastingInfo_actionID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "actionName":
			out.Values[i] = ec._CastingInfo_actionName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "startTime":
			out.Values[i] = ec._CastingInfo_startTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "castTime":
			out.Values[i] = ec._CastingInfo_castTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "targetID":
			out.Values[i] = ec._CastingInfo_targetID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "location":
			out.Values[i] = ec._CastingInfo_location(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "castType":
			out.Values[i] = ec._CastingInfo_castType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "effectRange":
			out.Values[i] = ec._CastingInfo_effectRange(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "xAxisModifier":
			out.Values[i] = ec._CastingInfo_xAxisModifier(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "omen":
			out.Values[i] = ec._CastingInfo_omen(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var chatEventImplementors = []string{"ChatEvent", "StreamEventType"}

func (ec *executionContext) _ChatEvent(ctx context.Context, sel ast.SelectionSet, obj *ChatEvent) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, chatEventImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ChatEvent")
		case "channelID":
			out.Values[i] = ec._ChatEvent_channelID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "channelWorld":
			out.Values[i] = ec._ChatEvent_channelWorld(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "channelType":
			out.Values[i] = ec._ChatEvent_channelType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "contentID":
			out.Values[i] = ec._ChatEvent_contentID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "entityID":
			out.Values[i] = ec._ChatEvent_entityID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "world":
			out.Values[i] = ec._ChatEvent_world(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._ChatEvent_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "message":
			out.Values[i] = ec._ChatEvent_message(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var classJobImplementors = []string{"ClassJob"}

func (ec *executionContext) _ClassJob(ctx context.Context, sel ast.SelectionSet, obj *ClassJob) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, classJobImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ClassJob")
		case "id":
			out.Values[i] = ec._ClassJob_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._ClassJob_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "abbreviation":
			out.Values[i] = ec._ClassJob_abbreviation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var craftingInfoImplementors = []string{"CraftingInfo"}

func (ec *executionContext) _CraftingInfo(ctx context.Context, sel ast.SelectionSet, obj *CraftingInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, craftingInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CraftingInfo")
		case "recipe":
			out.Values[i] = ec._CraftingInfo_recipe(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastCraftActionID":
			out.Values[i] = ec._CraftingInfo_lastCraftActionID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastCraftActionName":
			out.Values[i] = ec._CraftingInfo_lastCraftActionName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "stepNum":
			out.Values[i] = ec._CraftingInfo_stepNum(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "progress":
			out.Values[i] = ec._CraftingInfo_progress(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "progressDelta":
			out.Values[i] = ec._CraftingInfo_progressDelta(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "quality":
			out.Values[i] = ec._CraftingInfo_quality(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "qualityDelta":
			out.Values[i] = ec._CraftingInfo_qualityDelta(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hqChance":
			out.Values[i] = ec._CraftingInfo_hqChance(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "durability":
			out.Values[i] = ec._CraftingInfo_durability(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "durabilityDelta":
			out.Values[i] = ec._CraftingInfo_durabilityDelta(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "currentCondition":
			out.Values[i] = ec._CraftingInfo_currentCondition(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "previousCondition":
			out.Values[i] = ec._CraftingInfo_previousCondition(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "reuseProc":
			out.Values[i] = ec._CraftingInfo_reuseProc(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var enmityImplementors = []string{"Enmity"}

func (ec *executionContext) _Enmity(ctx context.Context, sel ast.SelectionSet, obj *Enmity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, enmityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Enmity")
		case "targetHateRanking":
			out.Values[i] = ec._Enmity_targetHateRanking(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "nearbyEnemyHate":
			out.Values[i] = ec._Enmity_nearbyEnemyHate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var entityImplementors = []string{"Entity"}

func (ec *executionContext) _Entity(ctx context.Context, sel ast.SelectionSet, obj *Entity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, entityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Entity")
		case "id":
			out.Values[i] = ec._Entity_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "index":
			out.Values[i] = ec._Entity_index(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._Entity_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "targetID":
			out.Values[i] = ec._Entity_targetID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "ownerID":
			out.Values[i] = ec._Entity_ownerID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "level":
			out.Values[i] = ec._Entity_level(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "classJob":
			out.Values[i] = ec._Entity_classJob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isNPC":
			out.Values[i] = ec._Entity_isNPC(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isEnemy":
			out.Values[i] = ec._Entity_isEnemy(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isPet":
			out.Values[i] = ec._Entity_isPet(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "bNPCInfo":
			out.Values[i] = ec._Entity_bNPCInfo(ctx, field, obj)
		case "resources":
			out.Values[i] = ec._Entity_resources(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "location":
			out.Values[i] = ec._Entity_location(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastAction":
			out.Values[i] = ec._Entity_lastAction(ctx, field, obj)
		case "statuses":
			out.Values[i] = ec._Entity_statuses(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lockonMarker":
			out.Values[i] = ec._Entity_lockonMarker(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "castingInfo":
			out.Values[i] = ec._Entity_castingInfo(ctx, field, obj)
		case "rawSpawnJSONData":
			out.Values[i] = ec._Entity_rawSpawnJSONData(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var entityEventImplementors = []string{"EntityEvent"}

func (ec *executionContext) _EntityEvent(ctx context.Context, sel ast.SelectionSet, obj *EntityEvent) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, entityEventImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("EntityEvent")
		case "streamID":
			out.Values[i] = ec._EntityEvent_streamID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "entityID":
			out.Values[i] = ec._EntityEvent_entityID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec._EntityEvent_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var hateEntryImplementors = []string{"HateEntry"}

func (ec *executionContext) _HateEntry(ctx context.Context, sel ast.SelectionSet, obj *HateEntry) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, hateEntryImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("HateEntry")
		case "enemyID":
			out.Values[i] = ec._HateEntry_enemyID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hatePercent":
			out.Values[i] = ec._HateEntry_hatePercent(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var hateRankingImplementors = []string{"HateRanking"}

func (ec *executionContext) _HateRanking(ctx context.Context, sel ast.SelectionSet, obj *HateRanking) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, hateRankingImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("HateRanking")
		case "actorID":
			out.Values[i] = ec._HateRanking_actorID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "hate":
			out.Values[i] = ec._HateRanking_hate(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var locationImplementors = []string{"Location"}

func (ec *executionContext) _Location(ctx context.Context, sel ast.SelectionSet, obj *Location) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, locationImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Location")
		case "x":
			out.Values[i] = ec._Location_x(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "y":
			out.Values[i] = ec._Location_y(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "z":
			out.Values[i] = ec._Location_z(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "orientation":
			out.Values[i] = ec._Location_orientation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastUpdated":
			out.Values[i] = ec._Location_lastUpdated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var mapInfoImplementors = []string{"MapInfo"}

func (ec *executionContext) _MapInfo(ctx context.Context, sel ast.SelectionSet, obj *MapInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, mapInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("MapInfo")
		case "key":
			out.Values[i] = ec._MapInfo_key(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "id":
			out.Values[i] = ec._MapInfo_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "SizeFactor":
			out.Values[i] = ec._MapInfo_SizeFactor(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "OffsetX":
			out.Values[i] = ec._MapInfo_OffsetX(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "OffsetY":
			out.Values[i] = ec._MapInfo_OffsetY(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "PlaceName":
			out.Values[i] = ec._MapInfo_PlaceName(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "PlaceNameSub":
			out.Values[i] = ec._MapInfo_PlaceNameSub(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "TerritoryType":
			out.Values[i] = ec._MapInfo_TerritoryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Mutation")
		case "sendStreamRequest":
			out.Values[i] = ec._Mutation_sendStreamRequest(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createAdminToken":
			out.Values[i] = ec._Mutation_createAdminToken(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "addPlugin":
			out.Values[i] = ec._Mutation_addPlugin(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "removePlugin":
			out.Values[i] = ec._Mutation_removePlugin(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var nPCInfoImplementors = []string{"NPCInfo"}

func (ec *executionContext) _NPCInfo(ctx context.Context, sel ast.SelectionSet, obj *NPCInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, nPCInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("NPCInfo")
		case "nameID":
			out.Values[i] = ec._NPCInfo_nameID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "baseID":
			out.Values[i] = ec._NPCInfo_baseID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "modelID":
			out.Values[i] = ec._NPCInfo_modelID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._NPCInfo_name(ctx, field, obj)
		case "size":
			out.Values[i] = ec._NPCInfo_size(ctx, field, obj)
		case "error":
			out.Values[i] = ec._NPCInfo_error(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var placeImplementors = []string{"Place"}

func (ec *executionContext) _Place(ctx context.Context, sel ast.SelectionSet, obj *Place) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, placeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Place")
		case "mapID":
			out.Values[i] = ec._Place_mapID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "territoryID":
			out.Values[i] = ec._Place_territoryID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "maps":
			out.Values[i] = ec._Place_maps(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "apiVersion":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_apiVersion(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "streams":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_streams(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "stream":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_stream(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "entity":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_entity(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "__type":
			out.Values[i] = ec._Query___type(ctx, field)
		case "__schema":
			out.Values[i] = ec._Query___schema(ctx, field)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var recipeInfoImplementors = []string{"RecipeInfo"}

func (ec *executionContext) _RecipeInfo(ctx context.Context, sel ast.SelectionSet, obj *RecipeInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, recipeInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RecipeInfo")
		case "id":
			out.Values[i] = ec._RecipeInfo_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._RecipeInfo_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "recipeLevel":
			out.Values[i] = ec._RecipeInfo_recipeLevel(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "element":
			out.Values[i] = ec._RecipeInfo_element(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "canHQ":
			out.Values[i] = ec._RecipeInfo_canHQ(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "difficulty":
			out.Values[i] = ec._RecipeInfo_difficulty(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "quality":
			out.Values[i] = ec._RecipeInfo_quality(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "durability":
			out.Values[i] = ec._RecipeInfo_durability(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var removeEntityImplementors = []string{"RemoveEntity", "EntityEventType"}

func (ec *executionContext) _RemoveEntity(ctx context.Context, sel ast.SelectionSet, obj *RemoveEntity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, removeEntityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RemoveEntity")
		case "id":
			out.Values[i] = ec._RemoveEntity_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var removeStatusImplementors = []string{"RemoveStatus", "EntityEventType"}

func (ec *executionContext) _RemoveStatus(ctx context.Context, sel ast.SelectionSet, obj *RemoveStatus) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, removeStatusImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RemoveStatus")
		case "index":
			out.Values[i] = ec._RemoveStatus_index(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var removeStreamImplementors = []string{"RemoveStream", "StreamEventType"}

func (ec *executionContext) _RemoveStream(ctx context.Context, sel ast.SelectionSet, obj *RemoveStream) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, removeStreamImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("RemoveStream")
		case "id":
			out.Values[i] = ec._RemoveStream_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var resourcesImplementors = []string{"Resources"}

func (ec *executionContext) _Resources(ctx context.Context, sel ast.SelectionSet, obj *Resources) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, resourcesImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Resources")
		case "hp":
			out.Values[i] = ec._Resources_hp(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mp":
			out.Values[i] = ec._Resources_mp(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "tp":
			out.Values[i] = ec._Resources_tp(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "maxHP":
			out.Values[i] = ec._Resources_maxHP(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "maxMP":
			out.Values[i] = ec._Resources_maxMP(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastTick":
			out.Values[i] = ec._Resources_lastTick(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var setEntitiesImplementors = []string{"SetEntities", "EntityEventType"}

func (ec *executionContext) _SetEntities(ctx context.Context, sel ast.SelectionSet, obj *SetEntities) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, setEntitiesImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("SetEntities")
		case "entities":
			out.Values[i] = ec._SetEntities_entities(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var statusImplementors = []string{"Status"}

func (ec *executionContext) _Status(ctx context.Context, sel ast.SelectionSet, obj *Status) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, statusImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Status")
		case "id":
			out.Values[i] = ec._Status_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "param":
			out.Values[i] = ec._Status_param(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._Status_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec._Status_description(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "startedTime":
			out.Values[i] = ec._Status_startedTime(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "duration":
			out.Values[i] = ec._Status_duration(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "actorID":
			out.Values[i] = ec._Status_actorID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "lastTick":
			out.Values[i] = ec._Status_lastTick(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var streamImplementors = []string{"Stream"}

func (ec *executionContext) _Stream(ctx context.Context, sel ast.SelectionSet, obj *Stream) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, streamImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Stream")
		case "id":
			out.Values[i] = ec._Stream_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "serverID":
			out.Values[i] = ec._Stream_serverID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "instanceNum":
			out.Values[i] = ec._Stream_instanceNum(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "characterID":
			out.Values[i] = ec._Stream_characterID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "homeWorld":
			out.Values[i] = ec._Stream_homeWorld(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "currentWorld":
			out.Values[i] = ec._Stream_currentWorld(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "place":
			out.Values[i] = ec._Stream_place(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "enmity":
			out.Values[i] = ec._Stream_enmity(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "craftingInfo":
			out.Values[i] = ec._Stream_craftingInfo(ctx, field, obj)
		case "entities":
			out.Values[i] = ec._Stream_entities(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var streamEventImplementors = []string{"StreamEvent"}

func (ec *executionContext) _StreamEvent(ctx context.Context, sel ast.SelectionSet, obj *StreamEvent) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, streamEventImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("StreamEvent")
		case "streamID":
			out.Values[i] = ec._StreamEvent_streamID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec._StreamEvent_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var subscriptionImplementors = []string{"Subscription"}

func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func() graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors)
	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Subscription",
	})
	if len(fields) != 1 {
		ec.Errorf(ctx, "must subscribe to exactly one stream")
		return nil
	}

	switch fields[0].Name {
	case "streamEvent":
		return ec._Subscription_streamEvent(ctx, fields[0])
	case "entityEvent":
		return ec._Subscription_entityEvent(ctx, fields[0])
	default:
		panic("unknown field " + strconv.Quote(fields[0].Name))
	}
}

var updateCastingInfoImplementors = []string{"UpdateCastingInfo", "EntityEventType"}

func (ec *executionContext) _UpdateCastingInfo(ctx context.Context, sel ast.SelectionSet, obj *UpdateCastingInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateCastingInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateCastingInfo")
		case "castingInfo":
			out.Values[i] = ec._UpdateCastingInfo_castingInfo(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateClassImplementors = []string{"UpdateClass", "EntityEventType"}

func (ec *executionContext) _UpdateClass(ctx context.Context, sel ast.SelectionSet, obj *UpdateClass) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateClassImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateClass")
		case "classJob":
			out.Values[i] = ec._UpdateClass_classJob(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "level":
			out.Values[i] = ec._UpdateClass_level(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateCraftingInfoImplementors = []string{"UpdateCraftingInfo", "StreamEventType"}

func (ec *executionContext) _UpdateCraftingInfo(ctx context.Context, sel ast.SelectionSet, obj *UpdateCraftingInfo) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateCraftingInfoImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateCraftingInfo")
		case "craftingInfo":
			out.Values[i] = ec._UpdateCraftingInfo_craftingInfo(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateEnmityImplementors = []string{"UpdateEnmity", "StreamEventType"}

func (ec *executionContext) _UpdateEnmity(ctx context.Context, sel ast.SelectionSet, obj *UpdateEnmity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateEnmityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateEnmity")
		case "enmity":
			out.Values[i] = ec._UpdateEnmity_enmity(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateIDsImplementors = []string{"UpdateIDs", "StreamEventType"}

func (ec *executionContext) _UpdateIDs(ctx context.Context, sel ast.SelectionSet, obj *UpdateIDs) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateIDsImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateIDs")
		case "serverID":
			out.Values[i] = ec._UpdateIDs_serverID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "instanceNum":
			out.Values[i] = ec._UpdateIDs_instanceNum(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "characterID":
			out.Values[i] = ec._UpdateIDs_characterID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "homeWorld":
			out.Values[i] = ec._UpdateIDs_homeWorld(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "currentWorld":
			out.Values[i] = ec._UpdateIDs_currentWorld(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateLastActionImplementors = []string{"UpdateLastAction", "EntityEventType"}

func (ec *executionContext) _UpdateLastAction(ctx context.Context, sel ast.SelectionSet, obj *UpdateLastAction) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateLastActionImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateLastAction")
		case "action":
			out.Values[i] = ec._UpdateLastAction_action(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateLocationImplementors = []string{"UpdateLocation", "EntityEventType"}

func (ec *executionContext) _UpdateLocation(ctx context.Context, sel ast.SelectionSet, obj *UpdateLocation) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateLocationImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateLocation")
		case "location":
			out.Values[i] = ec._UpdateLocation_location(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateLockonMarkerImplementors = []string{"UpdateLockonMarker", "EntityEventType"}

func (ec *executionContext) _UpdateLockonMarker(ctx context.Context, sel ast.SelectionSet, obj *UpdateLockonMarker) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateLockonMarkerImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateLockonMarker")
		case "lockonMarker":
			out.Values[i] = ec._UpdateLockonMarker_lockonMarker(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateMapImplementors = []string{"UpdateMap", "StreamEventType"}

func (ec *executionContext) _UpdateMap(ctx context.Context, sel ast.SelectionSet, obj *UpdateMap) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateMapImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateMap")
		case "place":
			out.Values[i] = ec._UpdateMap_place(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateResourcesImplementors = []string{"UpdateResources", "EntityEventType"}

func (ec *executionContext) _UpdateResources(ctx context.Context, sel ast.SelectionSet, obj *UpdateResources) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateResourcesImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateResources")
		case "resources":
			out.Values[i] = ec._UpdateResources_resources(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var updateTargetImplementors = []string{"UpdateTarget", "EntityEventType"}

func (ec *executionContext) _UpdateTarget(ctx context.Context, sel ast.SelectionSet, obj *UpdateTarget) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, updateTargetImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpdateTarget")
		case "targetID":
			out.Values[i] = ec._UpdateTarget_targetID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var upsertStatusImplementors = []string{"UpsertStatus", "EntityEventType"}

func (ec *executionContext) _UpsertStatus(ctx context.Context, sel ast.SelectionSet, obj *UpsertStatus) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, upsertStatusImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UpsertStatus")
		case "index":
			out.Values[i] = ec._UpsertStatus_index(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "status":
			out.Values[i] = ec._UpsertStatus_status(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var worldImplementors = []string{"World"}

func (ec *executionContext) _World(ctx context.Context, sel ast.SelectionSet, obj *World) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, worldImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("World")
		case "id":
			out.Values[i] = ec._World_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec._World_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	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 {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Directive_description(ctx, field, obj)
		case "locations":
			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	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 {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	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 {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Field_description(ctx, field, obj)
		case "args":
			out.Values[i] = ec.___Field_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	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 {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
		case "type":
			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mutationType":
			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
		case "directives":
			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	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)
	var invalids uint32
	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 {
				invalids++
			}
		case "name":
			out.Values[i] = ec.___Type_name(ctx, field, obj)
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

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

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

func (ec *executionContext) marshalNAction2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx context.Context, sel ast.SelectionSet, v Action) graphql.Marshaler {
	return ec._Action(ctx, sel, &v)
}

func (ec *executionContext) marshalNAction2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx context.Context, sel ast.SelectionSet, v *Action) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Action(ctx, sel, v)
}

func (ec *executionContext) marshalNActionEffect2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐActionEffect(ctx context.Context, sel ast.SelectionSet, v ActionEffect) graphql.Marshaler {
	return ec._ActionEffect(ctx, sel, &v)
}

func (ec *executionContext) marshalNActionEffect2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐActionEffectᚄ(ctx context.Context, sel ast.SelectionSet, v []ActionEffect) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNActionEffect2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐActionEffect(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	return graphql.UnmarshalBoolean(v)
}

func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	res := graphql.MarshalBoolean(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNClassJob2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐClassJob(ctx context.Context, sel ast.SelectionSet, v ClassJob) graphql.Marshaler {
	return ec._ClassJob(ctx, sel, &v)
}

func (ec *executionContext) marshalNClassJob2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐClassJob(ctx context.Context, sel ast.SelectionSet, v *ClassJob) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._ClassJob(ctx, sel, v)
}

func (ec *executionContext) marshalNEnmity2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEnmity(ctx context.Context, sel ast.SelectionSet, v Enmity) graphql.Marshaler {
	return ec._Enmity(ctx, sel, &v)
}

func (ec *executionContext) marshalNEnmity2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEnmity(ctx context.Context, sel ast.SelectionSet, v *Enmity) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Enmity(ctx, sel, v)
}

func (ec *executionContext) marshalNEntity2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntity(ctx context.Context, sel ast.SelectionSet, v Entity) graphql.Marshaler {
	return ec._Entity(ctx, sel, &v)
}

func (ec *executionContext) marshalNEntity2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityᚄ(ctx context.Context, sel ast.SelectionSet, v []Entity) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNEntity2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntity(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNEntity2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntity(ctx context.Context, sel ast.SelectionSet, v *Entity) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Entity(ctx, sel, v)
}

func (ec *executionContext) marshalNEntityEvent2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityEvent(ctx context.Context, sel ast.SelectionSet, v EntityEvent) graphql.Marshaler {
	return ec._EntityEvent(ctx, sel, &v)
}

func (ec *executionContext) marshalNEntityEvent2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityEvent(ctx context.Context, sel ast.SelectionSet, v *EntityEvent) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._EntityEvent(ctx, sel, v)
}

func (ec *executionContext) marshalNEntityEventType2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐEntityEventType(ctx context.Context, sel ast.SelectionSet, v EntityEventType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._EntityEventType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v interface{}) (float64, error) {
	return graphql.UnmarshalFloat(v)
}

func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
	res := graphql.MarshalFloat(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNHateEntry2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateEntry(ctx context.Context, sel ast.SelectionSet, v HateEntry) graphql.Marshaler {
	return ec._HateEntry(ctx, sel, &v)
}

func (ec *executionContext) marshalNHateEntry2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateEntryᚄ(ctx context.Context, sel ast.SelectionSet, v []HateEntry) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNHateEntry2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateEntry(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNHateRanking2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateRanking(ctx context.Context, sel ast.SelectionSet, v HateRanking) graphql.Marshaler {
	return ec._HateRanking(ctx, sel, &v)
}

func (ec *executionContext) marshalNHateRanking2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateRankingᚄ(ctx context.Context, sel ast.SelectionSet, v []HateRanking) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNHateRanking2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐHateRanking(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalID(v)
}

func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalID(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
	return graphql.UnmarshalInt(v)
}

func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	res := graphql.MarshalInt(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNLocation2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx context.Context, sel ast.SelectionSet, v Location) graphql.Marshaler {
	return ec._Location(ctx, sel, &v)
}

func (ec *executionContext) marshalNLocation2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐLocation(ctx context.Context, sel ast.SelectionSet, v *Location) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Location(ctx, sel, v)
}

func (ec *executionContext) marshalNMapInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐMapInfo(ctx context.Context, sel ast.SelectionSet, v MapInfo) graphql.Marshaler {
	return ec._MapInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalNMapInfo2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐMapInfoᚄ(ctx context.Context, sel ast.SelectionSet, v []MapInfo) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNMapInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐMapInfo(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNPlace2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐPlace(ctx context.Context, sel ast.SelectionSet, v Place) graphql.Marshaler {
	return ec._Place(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlace2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐPlace(ctx context.Context, sel ast.SelectionSet, v *Place) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Place(ctx, sel, v)
}

func (ec *executionContext) marshalNRecipeInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐRecipeInfo(ctx context.Context, sel ast.SelectionSet, v RecipeInfo) graphql.Marshaler {
	return ec._RecipeInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalNRecipeInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐRecipeInfo(ctx context.Context, sel ast.SelectionSet, v *RecipeInfo) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._RecipeInfo(ctx, sel, v)
}

func (ec *executionContext) marshalNResources2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐResources(ctx context.Context, sel ast.SelectionSet, v Resources) graphql.Marshaler {
	return ec._Resources(ctx, sel, &v)
}

func (ec *executionContext) marshalNResources2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐResources(ctx context.Context, sel ast.SelectionSet, v *Resources) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Resources(ctx, sel, v)
}

func (ec *executionContext) marshalNStatus2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v Status) graphql.Marshaler {
	return ec._Status(ctx, sel, &v)
}

func (ec *executionContext) marshalNStatus2ᚕᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v []*Status) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalOStatus2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNStatus2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v *Status) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Status(ctx, sel, v)
}

func (ec *executionContext) marshalNStream2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStream(ctx context.Context, sel ast.SelectionSet, v Stream) graphql.Marshaler {
	return ec._Stream(ctx, sel, &v)
}

func (ec *executionContext) marshalNStream2ᚕgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamᚄ(ctx context.Context, sel ast.SelectionSet, v []Stream) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNStream2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStream(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNStream2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStream(ctx context.Context, sel ast.SelectionSet, v *Stream) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Stream(ctx, sel, v)
}

func (ec *executionContext) marshalNStreamEvent2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamEvent(ctx context.Context, sel ast.SelectionSet, v StreamEvent) graphql.Marshaler {
	return ec._StreamEvent(ctx, sel, &v)
}

func (ec *executionContext) marshalNStreamEvent2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamEvent(ctx context.Context, sel ast.SelectionSet, v *StreamEvent) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._StreamEvent(ctx, sel, v)
}

func (ec *executionContext) marshalNStreamEventType2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamEventType(ctx context.Context, sel ast.SelectionSet, v StreamEventType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._StreamEventType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNStreamRequest2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStreamRequest(ctx context.Context, v interface{}) (StreamRequest, error) {
	return ec.unmarshalInputStreamRequest(ctx, v)
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNTimestamp2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	return UnmarshalTimestamp(v)
}

func (ec *executionContext) marshalNTimestamp2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	res := MarshalTimestamp(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNUint2uint64(ctx context.Context, v interface{}) (uint64, error) {
	return UnmarshalUint(v)
}

func (ec *executionContext) marshalNUint2uint64(ctx context.Context, sel ast.SelectionSet, v uint64) graphql.Marshaler {
	res := MarshalUint(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNWorld2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx context.Context, sel ast.SelectionSet, v World) graphql.Marshaler {
	return ec._World(ctx, sel, &v)
}

func (ec *executionContext) marshalNWorld2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐWorld(ctx context.Context, sel ast.SelectionSet, v *World) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._World(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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalOAction2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx context.Context, sel ast.SelectionSet, v Action) graphql.Marshaler {
	return ec._Action(ctx, sel, &v)
}

func (ec *executionContext) marshalOAction2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐAction(ctx context.Context, sel ast.SelectionSet, v *Action) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Action(ctx, sel, v)
}

func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	return graphql.UnmarshalBoolean(v)
}

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

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

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

func (ec *executionContext) marshalOCastingInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCastingInfo(ctx context.Context, sel ast.SelectionSet, v CastingInfo) graphql.Marshaler {
	return ec._CastingInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalOCastingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCastingInfo(ctx context.Context, sel ast.SelectionSet, v *CastingInfo) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CastingInfo(ctx, sel, v)
}

func (ec *executionContext) marshalOCraftingInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCraftingInfo(ctx context.Context, sel ast.SelectionSet, v CraftingInfo) graphql.Marshaler {
	return ec._CraftingInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalOCraftingInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐCraftingInfo(ctx context.Context, sel ast.SelectionSet, v *CraftingInfo) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CraftingInfo(ctx, sel, v)
}

func (ec *executionContext) unmarshalOFloat2float64(ctx context.Context, v interface{}) (float64, error) {
	return graphql.UnmarshalFloat(v)
}

func (ec *executionContext) marshalOFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
	return graphql.MarshalFloat(v)
}

func (ec *executionContext) unmarshalOFloat2ᚖfloat64(ctx context.Context, v interface{}) (*float64, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalOFloat2float64(ctx, v)
	return &res, err
}

func (ec *executionContext) marshalOFloat2ᚖfloat64(ctx context.Context, sel ast.SelectionSet, v *float64) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.marshalOFloat2float64(ctx, sel, *v)
}

func (ec *executionContext) marshalONPCInfo2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐNPCInfo(ctx context.Context, sel ast.SelectionSet, v NPCInfo) graphql.Marshaler {
	return ec._NPCInfo(ctx, sel, &v)
}

func (ec *executionContext) marshalONPCInfo2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐNPCInfo(ctx context.Context, sel ast.SelectionSet, v *NPCInfo) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._NPCInfo(ctx, sel, v)
}

func (ec *executionContext) marshalOStatus2githubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v Status) graphql.Marshaler {
	return ec._Status(ctx, sel, &v)
}

func (ec *executionContext) marshalOStatus2ᚖgithubᚗcomᚋff14wedᚋaetherometerᚋcoreᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v *Status) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Status(ctx, sel, v)
}

func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
	return graphql.UnmarshalString(v)
}

func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	return graphql.MarshalString(v)
}

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

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.marshalOString2string(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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

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

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__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) 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 := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	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 *****************************