entity.gql.go

// Code generated by scripts/gengraphql.go. DO NOT EDIT.

package schema

import (
	errors "errors"
	graphql1 "github.com/graphql-go/graphql"
	mapstructure "github.com/mitchellh/mapstructure"
	graphql "github.com/sensu/sensu-go/graphql"
	time "time"
)

// EntityIDFieldResolver implement to resolve requests for the Entity's id field.
type EntityIDFieldResolver interface {
	// ID implements response to request for id field.
	ID(p graphql.ResolveParams) (string, error)
}

// EntityNamespaceFieldResolver implement to resolve requests for the Entity's namespace field.
type EntityNamespaceFieldResolver interface {
	// Namespace implements response to request for namespace field.
	Namespace(p graphql.ResolveParams) (string, error)
}

// EntityMetadataFieldResolver implement to resolve requests for the Entity's metadata field.
type EntityMetadataFieldResolver interface {
	// Metadata implements response to request for metadata field.
	Metadata(p graphql.ResolveParams) (interface{}, error)
}

// EntityNameFieldResolver implement to resolve requests for the Entity's name field.
type EntityNameFieldResolver interface {
	// Name implements response to request for name field.
	Name(p graphql.ResolveParams) (string, error)
}

// EntityEntityClassFieldResolver implement to resolve requests for the Entity's entityClass field.
type EntityEntityClassFieldResolver interface {
	// EntityClass implements response to request for entityClass field.
	EntityClass(p graphql.ResolveParams) (string, error)
}

// EntitySystemFieldResolver implement to resolve requests for the Entity's system field.
type EntitySystemFieldResolver interface {
	// System implements response to request for system field.
	System(p graphql.ResolveParams) (interface{}, error)
}

// EntitySubscriptionsFieldResolver implement to resolve requests for the Entity's subscriptions field.
type EntitySubscriptionsFieldResolver interface {
	// Subscriptions implements response to request for subscriptions field.
	Subscriptions(p graphql.ResolveParams) ([]string, error)
}

// EntityLastSeenFieldResolver implement to resolve requests for the Entity's lastSeen field.
type EntityLastSeenFieldResolver interface {
	// LastSeen implements response to request for lastSeen field.
	LastSeen(p graphql.ResolveParams) (*time.Time, error)
}

// EntityDeregisterFieldResolver implement to resolve requests for the Entity's deregister field.
type EntityDeregisterFieldResolver interface {
	// Deregister implements response to request for deregister field.
	Deregister(p graphql.ResolveParams) (bool, error)
}

// EntityDeregistrationFieldResolver implement to resolve requests for the Entity's deregistration field.
type EntityDeregistrationFieldResolver interface {
	// Deregistration implements response to request for deregistration field.
	Deregistration(p graphql.ResolveParams) (interface{}, error)
}

// EntityUserFieldResolver implement to resolve requests for the Entity's user field.
type EntityUserFieldResolver interface {
	// User implements response to request for user field.
	User(p graphql.ResolveParams) (string, error)
}

// EntityRedactFieldResolver implement to resolve requests for the Entity's redact field.
type EntityRedactFieldResolver interface {
	// Redact implements response to request for redact field.
	Redact(p graphql.ResolveParams) ([]string, error)
}

// EntityStatusFieldResolver implement to resolve requests for the Entity's status field.
type EntityStatusFieldResolver interface {
	// Status implements response to request for status field.
	Status(p graphql.ResolveParams) (interface{}, error)
}

// EntityRelatedFieldResolverArgs contains arguments provided to related when selected
type EntityRelatedFieldResolverArgs struct {
	Limit int // Limit - self descriptive
}

// EntityRelatedFieldResolverParams contains contextual info to resolve related field
type EntityRelatedFieldResolverParams struct {
	graphql.ResolveParams
	Args EntityRelatedFieldResolverArgs
}

// EntityRelatedFieldResolver implement to resolve requests for the Entity's related field.
type EntityRelatedFieldResolver interface {
	// Related implements response to request for related field.
	Related(p EntityRelatedFieldResolverParams) (interface{}, error)
}

// EntityEventsFieldResolverArgs contains arguments provided to events when selected
type EntityEventsFieldResolverArgs struct {
	OrderBy EventsListOrder // OrderBy adds optional order to the records retrieved.
	Filters []string        /*
	Filters reduces the set using given arbitrary expression[s]; expressions
	take on the form KEY: VALUE. The accepted key(s) are: status, check, entity,
	& silenced.

	Eg.

	status:passing
	status:warning
	status:incident
	check:check-disk
	entity:venice
	silenced:true
	*/
}

// EntityEventsFieldResolverParams contains contextual info to resolve events field
type EntityEventsFieldResolverParams struct {
	graphql.ResolveParams
	Args EntityEventsFieldResolverArgs
}

// EntityEventsFieldResolver implement to resolve requests for the Entity's events field.
type EntityEventsFieldResolver interface {
	// Events implements response to request for events field.
	Events(p EntityEventsFieldResolverParams) (interface{}, error)
}

// EntityIsSilencedFieldResolver implement to resolve requests for the Entity's isSilenced field.
type EntityIsSilencedFieldResolver interface {
	// IsSilenced implements response to request for isSilenced field.
	IsSilenced(p graphql.ResolveParams) (bool, error)
}

// EntitySilencesFieldResolver implement to resolve requests for the Entity's silences field.
type EntitySilencesFieldResolver interface {
	// Silences implements response to request for silences field.
	Silences(p graphql.ResolveParams) (interface{}, error)
}

// EntityExtendedAttributesFieldResolver implement to resolve requests for the Entity's extendedAttributes field.
type EntityExtendedAttributesFieldResolver interface {
	// ExtendedAttributes implements response to request for extendedAttributes field.
	ExtendedAttributes(p graphql.ResolveParams) (interface{}, error)
}

// EntityToJSONFieldResolver implement to resolve requests for the Entity's toJSON field.
type EntityToJSONFieldResolver interface {
	// ToJSON implements response to request for toJSON field.
	ToJSON(p graphql.ResolveParams) (interface{}, error)
}

//
// EntityFieldResolvers represents a collection of methods whose products represent the
// response values of the 'Entity' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type EntityFieldResolvers interface {
	EntityIDFieldResolver
	EntityNamespaceFieldResolver
	EntityMetadataFieldResolver
	EntityNameFieldResolver
	EntityEntityClassFieldResolver
	EntitySystemFieldResolver
	EntitySubscriptionsFieldResolver
	EntityLastSeenFieldResolver
	EntityDeregisterFieldResolver
	EntityDeregistrationFieldResolver
	EntityUserFieldResolver
	EntityRedactFieldResolver
	EntityStatusFieldResolver
	EntityRelatedFieldResolver
	EntityEventsFieldResolver
	EntityIsSilencedFieldResolver
	EntitySilencesFieldResolver
	EntityExtendedAttributesFieldResolver
	EntityToJSONFieldResolver
}

// EntityAliases implements all methods on EntityFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type EntityAliases struct{}

// ID implements response to request for 'id' field.
func (_ EntityAliases) ID(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'id'")
	}
	return ret, err
}

// Namespace implements response to request for 'namespace' field.
func (_ EntityAliases) Namespace(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'namespace'")
	}
	return ret, err
}

// Metadata implements response to request for 'metadata' field.
func (_ EntityAliases) Metadata(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Name implements response to request for 'name' field.
func (_ EntityAliases) Name(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'name'")
	}
	return ret, err
}

// EntityClass implements response to request for 'entityClass' field.
func (_ EntityAliases) EntityClass(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'entityClass'")
	}
	return ret, err
}

// System implements response to request for 'system' field.
func (_ EntityAliases) System(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Subscriptions implements response to request for 'subscriptions' field.
func (_ EntityAliases) Subscriptions(p graphql.ResolveParams) ([]string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.([]string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'subscriptions'")
	}
	return ret, err
}

// LastSeen implements response to request for 'lastSeen' field.
func (_ EntityAliases) LastSeen(p graphql.ResolveParams) (*time.Time, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(*time.Time)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'lastSeen'")
	}
	return ret, err
}

// Deregister implements response to request for 'deregister' field.
func (_ EntityAliases) Deregister(p graphql.ResolveParams) (bool, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(bool)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'deregister'")
	}
	return ret, err
}

// Deregistration implements response to request for 'deregistration' field.
func (_ EntityAliases) Deregistration(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// User implements response to request for 'user' field.
func (_ EntityAliases) User(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'user'")
	}
	return ret, err
}

// Redact implements response to request for 'redact' field.
func (_ EntityAliases) Redact(p graphql.ResolveParams) ([]string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.([]string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'redact'")
	}
	return ret, err
}

// Status implements response to request for 'status' field.
func (_ EntityAliases) Status(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Related implements response to request for 'related' field.
func (_ EntityAliases) Related(p EntityRelatedFieldResolverParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Events implements response to request for 'events' field.
func (_ EntityAliases) Events(p EntityEventsFieldResolverParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// IsSilenced implements response to request for 'isSilenced' field.
func (_ EntityAliases) IsSilenced(p graphql.ResolveParams) (bool, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(bool)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'isSilenced'")
	}
	return ret, err
}

// Silences implements response to request for 'silences' field.
func (_ EntityAliases) Silences(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// ExtendedAttributes implements response to request for 'extendedAttributes' field.
func (_ EntityAliases) ExtendedAttributes(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// ToJSON implements response to request for 'toJSON' field.
func (_ EntityAliases) ToJSON(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

/*
EntityType Entity is the Entity supplying the event. The default Entity for any
Event is the running Agent process--if the Event is sent by an Agent.
*/
var EntityType = graphql.NewType("Entity", graphql.ObjectKind)

// RegisterEntity registers Entity object type with given service.
func RegisterEntity(svc *graphql.Service, impl EntityFieldResolvers) {
	svc.RegisterObject(_ObjectTypeEntityDesc, impl)
}
func _ObjTypeEntityIDHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityIDFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ID(frp)
	}
}

func _ObjTypeEntityNamespaceHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityNamespaceFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Namespace(frp)
	}
}

func _ObjTypeEntityMetadataHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityMetadataFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Metadata(frp)
	}
}

func _ObjTypeEntityNameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityNameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Name(frp)
	}
}

func _ObjTypeEntityEntityClassHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityEntityClassFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.EntityClass(frp)
	}
}

func _ObjTypeEntitySystemHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntitySystemFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.System(frp)
	}
}

func _ObjTypeEntitySubscriptionsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntitySubscriptionsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Subscriptions(frp)
	}
}

func _ObjTypeEntityLastSeenHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityLastSeenFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.LastSeen(frp)
	}
}

func _ObjTypeEntityDeregisterHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityDeregisterFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Deregister(frp)
	}
}

func _ObjTypeEntityDeregistrationHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityDeregistrationFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Deregistration(frp)
	}
}

func _ObjTypeEntityUserHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityUserFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.User(frp)
	}
}

func _ObjTypeEntityRedactHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityRedactFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Redact(frp)
	}
}

func _ObjTypeEntityStatusHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityStatusFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Status(frp)
	}
}

func _ObjTypeEntityRelatedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityRelatedFieldResolver)
	return func(p graphql1.ResolveParams) (interface{}, error) {
		frp := EntityRelatedFieldResolverParams{ResolveParams: p}
		err := mapstructure.Decode(p.Args, &frp.Args)
		if err != nil {
			return nil, err
		}

		return resolver.Related(frp)
	}
}

func _ObjTypeEntityEventsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityEventsFieldResolver)
	return func(p graphql1.ResolveParams) (interface{}, error) {
		frp := EntityEventsFieldResolverParams{ResolveParams: p}
		err := mapstructure.Decode(p.Args, &frp.Args)
		if err != nil {
			return nil, err
		}

		return resolver.Events(frp)
	}
}

func _ObjTypeEntityIsSilencedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityIsSilencedFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.IsSilenced(frp)
	}
}

func _ObjTypeEntitySilencesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntitySilencesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Silences(frp)
	}
}

func _ObjTypeEntityExtendedAttributesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityExtendedAttributesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ExtendedAttributes(frp)
	}
}

func _ObjTypeEntityToJSONHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityToJSONFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ToJSON(frp)
	}
}

func _ObjectTypeEntityConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "Entity is the Entity supplying the event. The default Entity for any\nEvent is the running Agent process--if the Event is sent by an Agent.",
		Fields: graphql1.Fields{
			"deregister": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "deregister",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"deregistration": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "deregistration",
				Type:              graphql1.NewNonNull(graphql.OutputType("Deregistration")),
			},
			"entityClass": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "entityClass",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"events": &graphql1.Field{
				Args: graphql1.FieldConfigArgument{
					"filters": &graphql1.ArgumentConfig{
						DefaultValue: []interface{}{},
						Description:  "Filters reduces the set using given arbitrary expression[s]; expressions\ntake on the form KEY: VALUE. The accepted key(s) are: status, check, entity,\n& silenced.\n\nEg.\n\nstatus:passing\nstatus:warning\nstatus:incident\ncheck:check-disk\nentity:venice\nsilenced:true",
						Type:         graphql1.NewList(graphql1.NewNonNull(graphql1.String)),
					},
					"orderBy": &graphql1.ArgumentConfig{
						DefaultValue: "SEVERITY",
						Description:  "OrderBy adds optional order to the records retrieved.",
						Type:         graphql.InputType("EventsListOrder"),
					},
				},
				DeprecationReason: "",
				Description:       "All events associated with the entity.",
				Name:              "events",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("Event")))),
			},
			"extendedAttributes": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Extended attributes includes arbitrary user-defined data",
				Name:              "extendedAttributes",
				Type:              graphql1.NewNonNull(graphql.OutputType("JSON")),
			},
			"id": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "The globally unique identifier of the record",
				Name:              "id",
				Type:              graphql1.NewNonNull(graphql1.ID),
			},
			"isSilenced": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "isSilenced return true if the entity has any silences associated with it.",
				Name:              "isSilenced",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"lastSeen": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "lastSeen",
				Type:              graphql1.DateTime,
			},
			"metadata": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "metadata contains name, namespace, labels and annotations of the record",
				Name:              "metadata",
				Type:              graphql1.NewNonNull(graphql.OutputType("ObjectMeta")),
			},
			"name": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "unique identifier for the entity",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"namespace": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Namespace in which this record resides",
				Name:              "namespace",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"redact": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Redact contains the fields to redact on the agent.",
				Name:              "redact",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"related": &graphql1.Field{
				Args: graphql1.FieldConfigArgument{"limit": &graphql1.ArgumentConfig{
					DefaultValue: 10,
					Description:  "self descriptive",
					Type:         graphql1.Int,
				}},
				DeprecationReason: "",
				Description:       "Related returns a sorted list of like entities from the same environment.",
				Name:              "related",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Entity"))),
			},
			"silences": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "All silences matching the entity's subscriptions and where the silence\nmatches all checks.",
				Name:              "silences",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("Silenced")))),
			},
			"status": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Status represents the MAX status of all events associated with the entity. If\nno events are present value is 0.",
				Name:              "status",
				Type:              graphql1.NewNonNull(graphql.OutputType("Uint")),
			},
			"subscriptions": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "subscriptions",
				Type:              graphql1.NewList(graphql1.NewNonNull(graphql1.String)),
			},
			"system": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "system",
				Type:              graphql1.NewNonNull(graphql.OutputType("System")),
			},
			"toJSON": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "toJSON returns a REST API compatible representation of the resource. Handy for\nsharing snippets that can then be imported with `sensuctl create`.",
				Name:              "toJSON",
				Type:              graphql1.NewNonNull(graphql.OutputType("JSON")),
			},
			"user": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "user",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{
			graphql.Interface("Node"),
			graphql.Interface("Namespaced"),
			graphql.Interface("Silenceable"),
			graphql.Interface("Resource")},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see EntityFieldResolvers.")
		},
		Name: "Entity",
	}
}

// describe Entity's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeEntityDesc = graphql.ObjectDesc{
	Config: _ObjectTypeEntityConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"deregister":         _ObjTypeEntityDeregisterHandler,
		"deregistration":     _ObjTypeEntityDeregistrationHandler,
		"entityClass":        _ObjTypeEntityEntityClassHandler,
		"events":             _ObjTypeEntityEventsHandler,
		"extendedAttributes": _ObjTypeEntityExtendedAttributesHandler,
		"id":                 _ObjTypeEntityIDHandler,
		"isSilenced":         _ObjTypeEntityIsSilencedHandler,
		"lastSeen":           _ObjTypeEntityLastSeenHandler,
		"metadata":           _ObjTypeEntityMetadataHandler,
		"name":               _ObjTypeEntityNameHandler,
		"namespace":          _ObjTypeEntityNamespaceHandler,
		"redact":             _ObjTypeEntityRedactHandler,
		"related":            _ObjTypeEntityRelatedHandler,
		"silences":           _ObjTypeEntitySilencesHandler,
		"status":             _ObjTypeEntityStatusHandler,
		"subscriptions":      _ObjTypeEntitySubscriptionsHandler,
		"system":             _ObjTypeEntitySystemHandler,
		"toJSON":             _ObjTypeEntityToJSONHandler,
		"user":               _ObjTypeEntityUserHandler,
	},
}

// SystemHostnameFieldResolver implement to resolve requests for the System's hostname field.
type SystemHostnameFieldResolver interface {
	// Hostname implements response to request for hostname field.
	Hostname(p graphql.ResolveParams) (string, error)
}

// SystemNetworkFieldResolver implement to resolve requests for the System's network field.
type SystemNetworkFieldResolver interface {
	// Network implements response to request for network field.
	Network(p graphql.ResolveParams) (interface{}, error)
}

// SystemOsFieldResolver implement to resolve requests for the System's os field.
type SystemOsFieldResolver interface {
	// Os implements response to request for os field.
	Os(p graphql.ResolveParams) (string, error)
}

// SystemPlatformFieldResolver implement to resolve requests for the System's platform field.
type SystemPlatformFieldResolver interface {
	// Platform implements response to request for platform field.
	Platform(p graphql.ResolveParams) (string, error)
}

// SystemPlatformFamilyFieldResolver implement to resolve requests for the System's platformFamily field.
type SystemPlatformFamilyFieldResolver interface {
	// PlatformFamily implements response to request for platformFamily field.
	PlatformFamily(p graphql.ResolveParams) (string, error)
}

// SystemPlatformVersionFieldResolver implement to resolve requests for the System's platformVersion field.
type SystemPlatformVersionFieldResolver interface {
	// PlatformVersion implements response to request for platformVersion field.
	PlatformVersion(p graphql.ResolveParams) (string, error)
}

// SystemArchFieldResolver implement to resolve requests for the System's arch field.
type SystemArchFieldResolver interface {
	// Arch implements response to request for arch field.
	Arch(p graphql.ResolveParams) (string, error)
}

//
// SystemFieldResolvers represents a collection of methods whose products represent the
// response values of the 'System' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type SystemFieldResolvers interface {
	SystemHostnameFieldResolver
	SystemNetworkFieldResolver
	SystemOsFieldResolver
	SystemPlatformFieldResolver
	SystemPlatformFamilyFieldResolver
	SystemPlatformVersionFieldResolver
	SystemArchFieldResolver
}

// SystemAliases implements all methods on SystemFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type SystemAliases struct{}

// Hostname implements response to request for 'hostname' field.
func (_ SystemAliases) Hostname(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'hostname'")
	}
	return ret, err
}

// Network implements response to request for 'network' field.
func (_ SystemAliases) Network(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Os implements response to request for 'os' field.
func (_ SystemAliases) Os(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'os'")
	}
	return ret, err
}

// Platform implements response to request for 'platform' field.
func (_ SystemAliases) Platform(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'platform'")
	}
	return ret, err
}

// PlatformFamily implements response to request for 'platformFamily' field.
func (_ SystemAliases) PlatformFamily(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'platformFamily'")
	}
	return ret, err
}

// PlatformVersion implements response to request for 'platformVersion' field.
func (_ SystemAliases) PlatformVersion(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'platformVersion'")
	}
	return ret, err
}

// Arch implements response to request for 'arch' field.
func (_ SystemAliases) Arch(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'arch'")
	}
	return ret, err
}

/*
SystemType System contains information about the system that the Agent process
is running on, used for additional Entity context.
*/
var SystemType = graphql.NewType("System", graphql.ObjectKind)

// RegisterSystem registers System object type with given service.
func RegisterSystem(svc *graphql.Service, impl SystemFieldResolvers) {
	svc.RegisterObject(_ObjectTypeSystemDesc, impl)
}
func _ObjTypeSystemHostnameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemHostnameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Hostname(frp)
	}
}

func _ObjTypeSystemNetworkHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemNetworkFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Network(frp)
	}
}

func _ObjTypeSystemOsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemOsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Os(frp)
	}
}

func _ObjTypeSystemPlatformHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemPlatformFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Platform(frp)
	}
}

func _ObjTypeSystemPlatformFamilyHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemPlatformFamilyFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.PlatformFamily(frp)
	}
}

func _ObjTypeSystemPlatformVersionHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemPlatformVersionFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.PlatformVersion(frp)
	}
}

func _ObjTypeSystemArchHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(SystemArchFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Arch(frp)
	}
}

func _ObjectTypeSystemConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "System contains information about the system that the Agent process\nis running on, used for additional Entity context.",
		Fields: graphql1.Fields{
			"arch": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Architecture; eg. 386, amd64, arm, ...",
				Name:              "arch",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"hostname": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "hostname",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"network": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "network",
				Type:              graphql1.NewNonNull(graphql.OutputType("Network")),
			},
			"os": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Operating system; eg. freebsd, linux, ...",
				Name:              "os",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"platform": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Operating system platform; eg. ubuntu, linuxmint, ...",
				Name:              "platform",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"platformFamily": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Operating system family; eg. debian, rhel, ...",
				Name:              "platformFamily",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"platformVersion": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Version of complete operating system; eg. 10.12.2, ...",
				Name:              "platformVersion",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see SystemFieldResolvers.")
		},
		Name: "System",
	}
}

// describe System's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeSystemDesc = graphql.ObjectDesc{
	Config: _ObjectTypeSystemConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"arch":            _ObjTypeSystemArchHandler,
		"hostname":        _ObjTypeSystemHostnameHandler,
		"network":         _ObjTypeSystemNetworkHandler,
		"os":              _ObjTypeSystemOsHandler,
		"platform":        _ObjTypeSystemPlatformHandler,
		"platformFamily":  _ObjTypeSystemPlatformFamilyHandler,
		"platformVersion": _ObjTypeSystemPlatformVersionHandler,
	},
}

// NetworkInterfacesFieldResolver implement to resolve requests for the Network's interfaces field.
type NetworkInterfacesFieldResolver interface {
	// Interfaces implements response to request for interfaces field.
	Interfaces(p graphql.ResolveParams) (interface{}, error)
}

//
// NetworkFieldResolvers represents a collection of methods whose products represent the
// response values of the 'Network' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type NetworkFieldResolvers interface {
	NetworkInterfacesFieldResolver
}

// NetworkAliases implements all methods on NetworkFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type NetworkAliases struct{}

// Interfaces implements response to request for 'interfaces' field.
func (_ NetworkAliases) Interfaces(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

/*
NetworkType Network contains information about the system network interfaces
that the Agent process is running on, used for additional Entity
context.
*/
var NetworkType = graphql.NewType("Network", graphql.ObjectKind)

// RegisterNetwork registers Network object type with given service.
func RegisterNetwork(svc *graphql.Service, impl NetworkFieldResolvers) {
	svc.RegisterObject(_ObjectTypeNetworkDesc, impl)
}
func _ObjTypeNetworkInterfacesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(NetworkInterfacesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Interfaces(frp)
	}
}

func _ObjectTypeNetworkConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "Network contains information about the system network interfaces\nthat the Agent process is running on, used for additional Entity\ncontext.",
		Fields: graphql1.Fields{"interfaces": &graphql1.Field{
			Args:              graphql1.FieldConfigArgument{},
			DeprecationReason: "",
			Description:       "self descriptive",
			Name:              "interfaces",
			Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("NetworkInterface")))),
		}},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see NetworkFieldResolvers.")
		},
		Name: "Network",
	}
}

// describe Network's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeNetworkDesc = graphql.ObjectDesc{
	Config:        _ObjectTypeNetworkConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{"interfaces": _ObjTypeNetworkInterfacesHandler},
}

// NetworkInterfaceNameFieldResolver implement to resolve requests for the NetworkInterface's name field.
type NetworkInterfaceNameFieldResolver interface {
	// Name implements response to request for name field.
	Name(p graphql.ResolveParams) (string, error)
}

// NetworkInterfaceMacFieldResolver implement to resolve requests for the NetworkInterface's mac field.
type NetworkInterfaceMacFieldResolver interface {
	// Mac implements response to request for mac field.
	Mac(p graphql.ResolveParams) (string, error)
}

// NetworkInterfaceAddressesFieldResolver implement to resolve requests for the NetworkInterface's addresses field.
type NetworkInterfaceAddressesFieldResolver interface {
	// Addresses implements response to request for addresses field.
	Addresses(p graphql.ResolveParams) ([]string, error)
}

//
// NetworkInterfaceFieldResolvers represents a collection of methods whose products represent the
// response values of the 'NetworkInterface' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type NetworkInterfaceFieldResolvers interface {
	NetworkInterfaceNameFieldResolver
	NetworkInterfaceMacFieldResolver
	NetworkInterfaceAddressesFieldResolver
}

// NetworkInterfaceAliases implements all methods on NetworkInterfaceFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type NetworkInterfaceAliases struct{}

// Name implements response to request for 'name' field.
func (_ NetworkInterfaceAliases) Name(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'name'")
	}
	return ret, err
}

// Mac implements response to request for 'mac' field.
func (_ NetworkInterfaceAliases) Mac(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'mac'")
	}
	return ret, err
}

// Addresses implements response to request for 'addresses' field.
func (_ NetworkInterfaceAliases) Addresses(p graphql.ResolveParams) ([]string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.([]string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'addresses'")
	}
	return ret, err
}

/*
NetworkInterfaceType NetworkInterface contains information about a system network
interface.
*/
var NetworkInterfaceType = graphql.NewType("NetworkInterface", graphql.ObjectKind)

// RegisterNetworkInterface registers NetworkInterface object type with given service.
func RegisterNetworkInterface(svc *graphql.Service, impl NetworkInterfaceFieldResolvers) {
	svc.RegisterObject(_ObjectTypeNetworkInterfaceDesc, impl)
}
func _ObjTypeNetworkInterfaceNameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(NetworkInterfaceNameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Name(frp)
	}
}

func _ObjTypeNetworkInterfaceMacHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(NetworkInterfaceMacFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Mac(frp)
	}
}

func _ObjTypeNetworkInterfaceAddressesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(NetworkInterfaceAddressesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Addresses(frp)
	}
}

func _ObjectTypeNetworkInterfaceConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "NetworkInterface contains information about a system network\ninterface.",
		Fields: graphql1.Fields{
			"addresses": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "IP address(es) associated with the network interface",
				Name:              "addresses",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"mac": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "MAC address associated with the network interface",
				Name:              "mac",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"name": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Name given to the network interface; en0, wi0, tunnel0, etc.",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see NetworkInterfaceFieldResolvers.")
		},
		Name: "NetworkInterface",
	}
}

// describe NetworkInterface's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeNetworkInterfaceDesc = graphql.ObjectDesc{
	Config: _ObjectTypeNetworkInterfaceConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"addresses": _ObjTypeNetworkInterfaceAddressesHandler,
		"mac":       _ObjTypeNetworkInterfaceMacHandler,
		"name":      _ObjTypeNetworkInterfaceNameHandler,
	},
}

// DeregistrationHandlerFieldResolver implement to resolve requests for the Deregistration's handler field.
type DeregistrationHandlerFieldResolver interface {
	// Handler implements response to request for handler field.
	Handler(p graphql.ResolveParams) (string, error)
}

//
// DeregistrationFieldResolvers represents a collection of methods whose products represent the
// response values of the 'Deregistration' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type DeregistrationFieldResolvers interface {
	DeregistrationHandlerFieldResolver
}

// DeregistrationAliases implements all methods on DeregistrationFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type DeregistrationAliases struct{}

// Handler implements response to request for 'handler' field.
func (_ DeregistrationAliases) Handler(p graphql.ResolveParams) (string, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := val.(string)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'handler'")
	}
	return ret, err
}

// DeregistrationType Deregistration contains configuration for Sensu entity de-registration.
var DeregistrationType = graphql.NewType("Deregistration", graphql.ObjectKind)

// RegisterDeregistration registers Deregistration object type with given service.
func RegisterDeregistration(svc *graphql.Service, impl DeregistrationFieldResolvers) {
	svc.RegisterObject(_ObjectTypeDeregistrationDesc, impl)
}
func _ObjTypeDeregistrationHandlerHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(DeregistrationHandlerFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Handler(frp)
	}
}

func _ObjectTypeDeregistrationConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "Deregistration contains configuration for Sensu entity de-registration.",
		Fields: graphql1.Fields{"handler": &graphql1.Field{
			Args:              graphql1.FieldConfigArgument{},
			DeprecationReason: "",
			Description:       "self descriptive",
			Name:              "handler",
			Type:              graphql1.NewNonNull(graphql1.String),
		}},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see DeregistrationFieldResolvers.")
		},
		Name: "Deregistration",
	}
}

// describe Deregistration's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeDeregistrationDesc = graphql.ObjectDesc{
	Config:        _ObjectTypeDeregistrationConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{"handler": _ObjTypeDeregistrationHandlerHandler},
}

// EntityConnectionNodesFieldResolver implement to resolve requests for the EntityConnection's nodes field.
type EntityConnectionNodesFieldResolver interface {
	// Nodes implements response to request for nodes field.
	Nodes(p graphql.ResolveParams) (interface{}, error)
}

// EntityConnectionPageInfoFieldResolver implement to resolve requests for the EntityConnection's pageInfo field.
type EntityConnectionPageInfoFieldResolver interface {
	// PageInfo implements response to request for pageInfo field.
	PageInfo(p graphql.ResolveParams) (interface{}, error)
}

//
// EntityConnectionFieldResolvers represents a collection of methods whose products represent the
// response values of the 'EntityConnection' type.
//
// == Example SDL
//
//   """
//   Dog's are not hooman.
//   """
//   type Dog implements Pet {
//     "name of this fine beast."
//     name:  String!
//
//     "breed of this silly animal; probably shibe."
//     breed: [Breed]
//   }
//
// == Example generated interface
//
//   // DogResolver ...
//   type DogFieldResolvers interface {
//     DogNameFieldResolver
//     DogBreedFieldResolver
//
//     // IsTypeOf is used to determine if a given value is associated with the Dog type
//     IsTypeOf(interface{}, graphql.IsTypeOfParams) bool
//   }
//
// == Example implementation ...
//
//   // DogResolver implements DogFieldResolvers interface
//   type DogResolver struct {
//     logger logrus.LogEntry
//     store interface{
//       store.BreedStore
//       store.DogStore
//     }
//   }
//
//   // Name implements response to request for name field.
//   func (r *DogResolver) Name(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     return dog.GetName()
//   }
//
//   // Breed implements response to request for breed field.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // ... implementation details ...
//     dog := p.Source.(DogGetter)
//     breed := r.store.GetBreed(dog.GetBreedName())
//     return breed
//   }
//
//   // IsTypeOf is used to determine if a given value is associated with the Dog type
//   func (r *DogResolver) IsTypeOf(p graphql.IsTypeOfParams) bool {
//     // ... implementation details ...
//     _, ok := p.Value.(DogGetter)
//     return ok
//   }
//
type EntityConnectionFieldResolvers interface {
	EntityConnectionNodesFieldResolver
	EntityConnectionPageInfoFieldResolver
}

// EntityConnectionAliases implements all methods on EntityConnectionFieldResolvers interface by using reflection to
// match name of field to a field on the given value. Intent is reduce friction
// of writing new resolvers by removing all the instances where you would simply
// have the resolvers method return a field.
//
// == Example SDL
//
//    type Dog {
//      name:   String!
//      weight: Float!
//      dob:    DateTime
//      breed:  [Breed]
//    }
//
// == Example generated aliases
//
//   type DogAliases struct {}
//   func (_ DogAliases) Name(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Weight(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Dob(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//   func (_ DogAliases) Breed(p graphql.ResolveParams) (interface{}, error) {
//     // reflect...
//   }
//
// == Example Implementation
//
//   type DogResolver struct { // Implements DogResolver
//     DogAliases
//     store store.BreedStore
//   }
//
//   // NOTE:
//   // All other fields are satisified by DogAliases but since this one
//   // requires hitting the store we implement it in our resolver.
//   func (r *DogResolver) Breed(p graphql.ResolveParams) interface{} {
//     dog := v.(*Dog)
//     return r.BreedsById(dog.BreedIDs)
//   }
//
type EntityConnectionAliases struct{}

// Nodes implements response to request for 'nodes' field.
func (_ EntityConnectionAliases) Nodes(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// PageInfo implements response to request for 'pageInfo' field.
func (_ EntityConnectionAliases) PageInfo(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// EntityConnectionType A connection to a sequence of records.
var EntityConnectionType = graphql.NewType("EntityConnection", graphql.ObjectKind)

// RegisterEntityConnection registers EntityConnection object type with given service.
func RegisterEntityConnection(svc *graphql.Service, impl EntityConnectionFieldResolvers) {
	svc.RegisterObject(_ObjectTypeEntityConnectionDesc, impl)
}
func _ObjTypeEntityConnectionNodesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityConnectionNodesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Nodes(frp)
	}
}

func _ObjTypeEntityConnectionPageInfoHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(EntityConnectionPageInfoFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.PageInfo(frp)
	}
}

func _ObjectTypeEntityConnectionConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "A connection to a sequence of records.",
		Fields: graphql1.Fields{
			"nodes": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "nodes",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("Entity")))),
			},
			"pageInfo": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "pageInfo",
				Type:              graphql1.NewNonNull(graphql.OutputType("OffsetPageInfo")),
			},
		},
		Interfaces: []*graphql1.Interface{},
		IsTypeOf: func(_ graphql1.IsTypeOfParams) bool {
			// NOTE:
			// Panic by default. Intent is that when Service is invoked, values of
			// these fields are updated with instantiated resolvers. If these
			// defaults are called it is most certainly programmer err.
			// If you're see this comment then: 'Whoops! Sorry, my bad.'
			panic("Unimplemented; see EntityConnectionFieldResolvers.")
		},
		Name: "EntityConnection",
	}
}

// describe EntityConnection's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeEntityConnectionDesc = graphql.ObjectDesc{
	Config: _ObjectTypeEntityConnectionConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"nodes":    _ObjTypeEntityConnectionNodesHandler,
		"pageInfo": _ObjTypeEntityConnectionPageInfoHandler,
	},
}

// EntityListOrder Describes ways in which a list of entities can be ordered.
type EntityListOrder string

// EntityListOrders holds enum values
var EntityListOrders = _EnumTypeEntityListOrderValues{
	ID:       "ID",
	ID_DESC:  "ID_DESC",
	LASTSEEN: "LASTSEEN",
}

// EntityListOrderType Describes ways in which a list of entities can be ordered.
var EntityListOrderType = graphql.NewType("EntityListOrder", graphql.EnumKind)

// RegisterEntityListOrder registers EntityListOrder object type with given service.
func RegisterEntityListOrder(svc *graphql.Service) {
	svc.RegisterEnum(_EnumTypeEntityListOrderDesc)
}
func _EnumTypeEntityListOrderConfigFn() graphql1.EnumConfig {
	return graphql1.EnumConfig{
		Description: "Describes ways in which a list of entities can be ordered.",
		Name:        "EntityListOrder",
		Values: graphql1.EnumValueConfigMap{
			"ID": &graphql1.EnumValueConfig{
				DeprecationReason: "",
				Description:       "self descriptive",
				Value:             "ID",
			},
			"ID_DESC": &graphql1.EnumValueConfig{
				DeprecationReason: "",
				Description:       "self descriptive",
				Value:             "ID_DESC",
			},
			"LASTSEEN": &graphql1.EnumValueConfig{
				DeprecationReason: "",
				Description:       "self descriptive",
				Value:             "LASTSEEN",
			},
		},
	}
}

// describe EntityListOrder's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _EnumTypeEntityListOrderDesc = graphql.EnumDesc{Config: _EnumTypeEntityListOrderConfigFn}

type _EnumTypeEntityListOrderValues struct {
	// ID - self descriptive
	ID EntityListOrder
	// ID_DESC - self descriptive
	ID_DESC EntityListOrder
	// LASTSEEN - self descriptive
	LASTSEEN EntityListOrder
}