check.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"
)

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

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

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

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

// CheckConfigCommandFieldResolver implement to resolve requests for the CheckConfig's command field.
type CheckConfigCommandFieldResolver interface {
	// Command implements response to request for command field.
	Command(p graphql.ResolveParams) (string, error)
}

// CheckConfigCheckHooksFieldResolver implement to resolve requests for the CheckConfig's checkHooks field.
type CheckConfigCheckHooksFieldResolver interface {
	// CheckHooks implements response to request for checkHooks field.
	CheckHooks(p graphql.ResolveParams) (interface{}, error)
}

// CheckConfigCronFieldResolver implement to resolve requests for the CheckConfig's cron field.
type CheckConfigCronFieldResolver interface {
	// Cron implements response to request for cron field.
	Cron(p graphql.ResolveParams) (string, error)
}

// CheckConfigEnvVarsFieldResolver implement to resolve requests for the CheckConfig's envVars field.
type CheckConfigEnvVarsFieldResolver interface {
	// EnvVars implements response to request for envVars field.
	EnvVars(p graphql.ResolveParams) ([]string, error)
}

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

// CheckConfigHandlersFieldResolver implement to resolve requests for the CheckConfig's handlers field.
type CheckConfigHandlersFieldResolver interface {
	// Handlers implements response to request for handlers field.
	Handlers(p graphql.ResolveParams) (interface{}, error)
}

// CheckConfigHighFlapThresholdFieldResolver implement to resolve requests for the CheckConfig's highFlapThreshold field.
type CheckConfigHighFlapThresholdFieldResolver interface {
	// HighFlapThreshold implements response to request for highFlapThreshold field.
	HighFlapThreshold(p graphql.ResolveParams) (int, error)
}

// CheckConfigIntervalFieldResolver implement to resolve requests for the CheckConfig's interval field.
type CheckConfigIntervalFieldResolver interface {
	// Interval implements response to request for interval field.
	Interval(p graphql.ResolveParams) (int, error)
}

// CheckConfigLowFlapThresholdFieldResolver implement to resolve requests for the CheckConfig's lowFlapThreshold field.
type CheckConfigLowFlapThresholdFieldResolver interface {
	// LowFlapThreshold implements response to request for lowFlapThreshold field.
	LowFlapThreshold(p graphql.ResolveParams) (int, error)
}

// CheckConfigOutputMetricFormatFieldResolver implement to resolve requests for the CheckConfig's outputMetricFormat field.
type CheckConfigOutputMetricFormatFieldResolver interface {
	// OutputMetricFormat implements response to request for outputMetricFormat field.
	OutputMetricFormat(p graphql.ResolveParams) (string, error)
}

// CheckConfigOutputMetricHandlersFieldResolver implement to resolve requests for the CheckConfig's outputMetricHandlers field.
type CheckConfigOutputMetricHandlersFieldResolver interface {
	// OutputMetricHandlers implements response to request for outputMetricHandlers field.
	OutputMetricHandlers(p graphql.ResolveParams) (interface{}, error)
}

// CheckConfigProxyEntityNameFieldResolver implement to resolve requests for the CheckConfig's proxyEntityName field.
type CheckConfigProxyEntityNameFieldResolver interface {
	// ProxyEntityName implements response to request for proxyEntityName field.
	ProxyEntityName(p graphql.ResolveParams) (string, error)
}

// CheckConfigProxyRequestsFieldResolver implement to resolve requests for the CheckConfig's proxyRequests field.
type CheckConfigProxyRequestsFieldResolver interface {
	// ProxyRequests implements response to request for proxyRequests field.
	ProxyRequests(p graphql.ResolveParams) (interface{}, error)
}

// CheckConfigPublishFieldResolver implement to resolve requests for the CheckConfig's publish field.
type CheckConfigPublishFieldResolver interface {
	// Publish implements response to request for publish field.
	Publish(p graphql.ResolveParams) (bool, error)
}

// CheckConfigRuntimeAssetsFieldResolver implement to resolve requests for the CheckConfig's runtimeAssets field.
type CheckConfigRuntimeAssetsFieldResolver interface {
	// RuntimeAssets implements response to request for runtimeAssets field.
	RuntimeAssets(p graphql.ResolveParams) (interface{}, error)
}

// CheckConfigRoundRobinFieldResolver implement to resolve requests for the CheckConfig's roundRobin field.
type CheckConfigRoundRobinFieldResolver interface {
	// RoundRobin implements response to request for roundRobin field.
	RoundRobin(p graphql.ResolveParams) (bool, error)
}

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

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

// CheckConfigStdinFieldResolver implement to resolve requests for the CheckConfig's stdin field.
type CheckConfigStdinFieldResolver interface {
	// Stdin implements response to request for stdin field.
	Stdin(p graphql.ResolveParams) (bool, error)
}

// CheckConfigSubdueFieldResolver implement to resolve requests for the CheckConfig's subdue field.
type CheckConfigSubdueFieldResolver interface {
	// Subdue implements response to request for subdue field.
	Subdue(p graphql.ResolveParams) (interface{}, error)
}

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

// CheckConfigTimeoutFieldResolver implement to resolve requests for the CheckConfig's timeout field.
type CheckConfigTimeoutFieldResolver interface {
	// Timeout implements response to request for timeout field.
	Timeout(p graphql.ResolveParams) (int, error)
}

// CheckConfigTtlFieldResolver implement to resolve requests for the CheckConfig's ttl field.
type CheckConfigTtlFieldResolver interface {
	// Ttl implements response to request for ttl field.
	Ttl(p graphql.ResolveParams) (int, error)
}

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

//
// CheckConfigFieldResolvers represents a collection of methods whose products represent the
// response values of the 'CheckConfig' 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 CheckConfigFieldResolvers interface {
	CheckConfigIDFieldResolver
	CheckConfigNamespaceFieldResolver
	CheckConfigNameFieldResolver
	CheckConfigMetadataFieldResolver
	CheckConfigCommandFieldResolver
	CheckConfigCheckHooksFieldResolver
	CheckConfigCronFieldResolver
	CheckConfigEnvVarsFieldResolver
	CheckConfigExtendedAttributesFieldResolver
	CheckConfigHandlersFieldResolver
	CheckConfigHighFlapThresholdFieldResolver
	CheckConfigIntervalFieldResolver
	CheckConfigLowFlapThresholdFieldResolver
	CheckConfigOutputMetricFormatFieldResolver
	CheckConfigOutputMetricHandlersFieldResolver
	CheckConfigProxyEntityNameFieldResolver
	CheckConfigProxyRequestsFieldResolver
	CheckConfigPublishFieldResolver
	CheckConfigRuntimeAssetsFieldResolver
	CheckConfigRoundRobinFieldResolver
	CheckConfigIsSilencedFieldResolver
	CheckConfigSilencesFieldResolver
	CheckConfigStdinFieldResolver
	CheckConfigSubdueFieldResolver
	CheckConfigSubscriptionsFieldResolver
	CheckConfigTimeoutFieldResolver
	CheckConfigTtlFieldResolver
	CheckConfigToJSONFieldResolver
}

// CheckConfigAliases implements all methods on CheckConfigFieldResolvers 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 CheckConfigAliases struct{}

// ID implements response to request for 'id' field.
func (_ CheckConfigAliases) 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 (_ CheckConfigAliases) 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
}

// Name implements response to request for 'name' field.
func (_ CheckConfigAliases) 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
}

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

// Command implements response to request for 'command' field.
func (_ CheckConfigAliases) Command(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 'command'")
	}
	return ret, err
}

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

// Cron implements response to request for 'cron' field.
func (_ CheckConfigAliases) Cron(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 'cron'")
	}
	return ret, err
}

// EnvVars implements response to request for 'envVars' field.
func (_ CheckConfigAliases) EnvVars(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 'envVars'")
	}
	return ret, err
}

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

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

// HighFlapThreshold implements response to request for 'highFlapThreshold' field.
func (_ CheckConfigAliases) HighFlapThreshold(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'highFlapThreshold'")
	}
	return ret, err
}

// Interval implements response to request for 'interval' field.
func (_ CheckConfigAliases) Interval(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'interval'")
	}
	return ret, err
}

// LowFlapThreshold implements response to request for 'lowFlapThreshold' field.
func (_ CheckConfigAliases) LowFlapThreshold(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'lowFlapThreshold'")
	}
	return ret, err
}

// OutputMetricFormat implements response to request for 'outputMetricFormat' field.
func (_ CheckConfigAliases) OutputMetricFormat(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 'outputMetricFormat'")
	}
	return ret, err
}

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

// ProxyEntityName implements response to request for 'proxyEntityName' field.
func (_ CheckConfigAliases) ProxyEntityName(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 'proxyEntityName'")
	}
	return ret, err
}

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

// Publish implements response to request for 'publish' field.
func (_ CheckConfigAliases) Publish(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 'publish'")
	}
	return ret, err
}

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

// RoundRobin implements response to request for 'roundRobin' field.
func (_ CheckConfigAliases) RoundRobin(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 'roundRobin'")
	}
	return ret, err
}

// IsSilenced implements response to request for 'isSilenced' field.
func (_ CheckConfigAliases) 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 (_ CheckConfigAliases) Silences(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Stdin implements response to request for 'stdin' field.
func (_ CheckConfigAliases) Stdin(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 'stdin'")
	}
	return ret, err
}

// Subdue implements response to request for 'subdue' field.
func (_ CheckConfigAliases) Subdue(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 (_ CheckConfigAliases) 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
}

// Timeout implements response to request for 'timeout' field.
func (_ CheckConfigAliases) Timeout(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'timeout'")
	}
	return ret, err
}

// Ttl implements response to request for 'ttl' field.
func (_ CheckConfigAliases) Ttl(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'ttl'")
	}
	return ret, err
}

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

// CheckConfigType CheckConfig is the specification of a check.
var CheckConfigType = graphql.NewType("CheckConfig", graphql.ObjectKind)

// RegisterCheckConfig registers CheckConfig object type with given service.
func RegisterCheckConfig(svc *graphql.Service, impl CheckConfigFieldResolvers) {
	svc.RegisterObject(_ObjectTypeCheckConfigDesc, impl)
}
func _ObjTypeCheckConfigIDHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigIDFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ID(frp)
	}
}

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

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

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

func _ObjTypeCheckConfigCommandHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigCommandFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Command(frp)
	}
}

func _ObjTypeCheckConfigCheckHooksHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigCheckHooksFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.CheckHooks(frp)
	}
}

func _ObjTypeCheckConfigCronHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigCronFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Cron(frp)
	}
}

func _ObjTypeCheckConfigEnvVarsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigEnvVarsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.EnvVars(frp)
	}
}

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

func _ObjTypeCheckConfigHandlersHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigHandlersFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Handlers(frp)
	}
}

func _ObjTypeCheckConfigHighFlapThresholdHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigHighFlapThresholdFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.HighFlapThreshold(frp)
	}
}

func _ObjTypeCheckConfigIntervalHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigIntervalFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Interval(frp)
	}
}

func _ObjTypeCheckConfigLowFlapThresholdHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigLowFlapThresholdFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.LowFlapThreshold(frp)
	}
}

func _ObjTypeCheckConfigOutputMetricFormatHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigOutputMetricFormatFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.OutputMetricFormat(frp)
	}
}

func _ObjTypeCheckConfigOutputMetricHandlersHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigOutputMetricHandlersFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.OutputMetricHandlers(frp)
	}
}

func _ObjTypeCheckConfigProxyEntityNameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigProxyEntityNameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ProxyEntityName(frp)
	}
}

func _ObjTypeCheckConfigProxyRequestsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigProxyRequestsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ProxyRequests(frp)
	}
}

func _ObjTypeCheckConfigPublishHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigPublishFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Publish(frp)
	}
}

func _ObjTypeCheckConfigRuntimeAssetsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigRuntimeAssetsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.RuntimeAssets(frp)
	}
}

func _ObjTypeCheckConfigRoundRobinHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigRoundRobinFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.RoundRobin(frp)
	}
}

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

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

func _ObjTypeCheckConfigStdinHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigStdinFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Stdin(frp)
	}
}

func _ObjTypeCheckConfigSubdueHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigSubdueFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Subdue(frp)
	}
}

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

func _ObjTypeCheckConfigTimeoutHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigTimeoutFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Timeout(frp)
	}
}

func _ObjTypeCheckConfigTtlHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigTtlFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Ttl(frp)
	}
}

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

func _ObjectTypeCheckConfigConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "CheckConfig is the specification of a check.",
		Fields: graphql1.Fields{
			"checkHooks": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "CheckHooks is the configured list of check hooks for the check",
				Name:              "checkHooks",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("HookList")))),
			},
			"command": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "command is the command to be executed.",
				Name:              "command",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"cron": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Cron is the cron string at which the check should be run.",
				Name:              "cron",
				Type:              graphql1.String,
			},
			"envVars": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "EnvVars is the list of environment variables to set for the check's\nexecution environment.",
				Name:              "envVars",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"extendedAttributes": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "ExtendedAttributes store serialized arbitrary JSON-encoded data",
				Name:              "extendedAttributes",
				Type:              graphql1.NewNonNull(graphql.OutputType("JSON")),
			},
			"handlers": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "handlers are the event handler for the check (incidents and/or metrics).",
				Name:              "handlers",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Handler"))),
			},
			"highFlapThreshold": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "HighFlapThreshold is the flap detection high threshold (% state change) for\nthe check. Sensu uses the same flap detection algorithm as Nagios.",
				Name:              "highFlapThreshold",
				Type:              graphql1.Int,
			},
			"id": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "The globally unique identifier of the check.",
				Name:              "id",
				Type:              graphql1.NewNonNull(graphql1.ID),
			},
			"interval": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Interval is the interval, in seconds, at which the check should be run.",
				Name:              "interval",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"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),
			},
			"lowFlapThreshold": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "LowFlapThreshold is the flap detection low threshold (% state change) for\nthe check. Sensu uses the same flap detection algorithm as Nagios.",
				Name:              "lowFlapThreshold",
				Type:              graphql1.Int,
			},
			"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:       "name is the unique identifier for a check",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"namespace": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "namespace in which this check resides",
				Name:              "namespace",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"outputMetricFormat": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "OutputOutputMetricFormat is the metric protocol that the check's output will be\nexpected to follow in order to be extracted.",
				Name:              "outputMetricFormat",
				Type:              graphql1.String,
			},
			"outputMetricHandlers": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "OutputOutputMetricHandlers is the list of event handlers that will respond to metrics\nthat have been extracted from the check.",
				Name:              "outputMetricHandlers",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Handler"))),
			},
			"proxyEntityName": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "proxyEntityName indicates the name of the entity representing an external resource",
				Name:              "proxyEntityName",
				Type:              graphql1.String,
			},
			"proxyRequests": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "proxyRequests represents a request to execute a proxy check.",
				Name:              "proxyRequests",
				Type:              graphql.OutputType("ProxyRequests"),
			},
			"publish": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Publish indicates if check requests are published for the check",
				Name:              "publish",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"roundRobin": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "RoundRobin enables round-robin scheduling if set true.",
				Name:              "roundRobin",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"runtimeAssets": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "RuntimeAssets are a list of assets required to execute check.",
				Name:              "runtimeAssets",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Asset"))),
			},
			"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")))),
			},
			"stdin": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "STDIN indicates if the check command accepts JSON via stdin from the agent",
				Name:              "stdin",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"subdue": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Subdue represents one or more time windows when the check should be subdued.",
				Name:              "subdue",
				Type:              graphql.OutputType("TimeWindowWhen"),
			},
			"subscriptions": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Subscriptions is the list of subscribers for the check.",
				Name:              "subscriptions",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.String)),
			},
			"timeout": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Timeout is the timeout, in seconds, at which the check has to run.",
				Name:              "timeout",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"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")),
			},
			"ttl": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "TTL represents the length of time in seconds for which a check result is valid.",
				Name:              "ttl",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
		},
		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 CheckConfigFieldResolvers.")
		},
		Name: "CheckConfig",
	}
}

// describe CheckConfig's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeCheckConfigDesc = graphql.ObjectDesc{
	Config: _ObjectTypeCheckConfigConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"checkHooks":           _ObjTypeCheckConfigCheckHooksHandler,
		"command":              _ObjTypeCheckConfigCommandHandler,
		"cron":                 _ObjTypeCheckConfigCronHandler,
		"envVars":              _ObjTypeCheckConfigEnvVarsHandler,
		"extendedAttributes":   _ObjTypeCheckConfigExtendedAttributesHandler,
		"handlers":             _ObjTypeCheckConfigHandlersHandler,
		"highFlapThreshold":    _ObjTypeCheckConfigHighFlapThresholdHandler,
		"id":                   _ObjTypeCheckConfigIDHandler,
		"interval":             _ObjTypeCheckConfigIntervalHandler,
		"isSilenced":           _ObjTypeCheckConfigIsSilencedHandler,
		"lowFlapThreshold":     _ObjTypeCheckConfigLowFlapThresholdHandler,
		"metadata":             _ObjTypeCheckConfigMetadataHandler,
		"name":                 _ObjTypeCheckConfigNameHandler,
		"namespace":            _ObjTypeCheckConfigNamespaceHandler,
		"outputMetricFormat":   _ObjTypeCheckConfigOutputMetricFormatHandler,
		"outputMetricHandlers": _ObjTypeCheckConfigOutputMetricHandlersHandler,
		"proxyEntityName":      _ObjTypeCheckConfigProxyEntityNameHandler,
		"proxyRequests":        _ObjTypeCheckConfigProxyRequestsHandler,
		"publish":              _ObjTypeCheckConfigPublishHandler,
		"roundRobin":           _ObjTypeCheckConfigRoundRobinHandler,
		"runtimeAssets":        _ObjTypeCheckConfigRuntimeAssetsHandler,
		"silences":             _ObjTypeCheckConfigSilencesHandler,
		"stdin":                _ObjTypeCheckConfigStdinHandler,
		"subdue":               _ObjTypeCheckConfigSubdueHandler,
		"subscriptions":        _ObjTypeCheckConfigSubscriptionsHandler,
		"timeout":              _ObjTypeCheckConfigTimeoutHandler,
		"toJSON":               _ObjTypeCheckConfigToJSONHandler,
		"ttl":                  _ObjTypeCheckConfigTtlHandler,
	},
}

// CheckNodeIDFieldResolver implement to resolve requests for the Check's nodeId field.
type CheckNodeIDFieldResolver interface {
	// NodeID implements response to request for nodeId field.
	NodeID(p graphql.ResolveParams) (string, error)
}

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

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

// CheckCommandFieldResolver implement to resolve requests for the Check's command field.
type CheckCommandFieldResolver interface {
	// Command implements response to request for command field.
	Command(p graphql.ResolveParams) (string, error)
}

// CheckCheckHooksFieldResolver implement to resolve requests for the Check's checkHooks field.
type CheckCheckHooksFieldResolver interface {
	// CheckHooks implements response to request for checkHooks field.
	CheckHooks(p graphql.ResolveParams) (interface{}, error)
}

// CheckEnvVarsFieldResolver implement to resolve requests for the Check's envVars field.
type CheckEnvVarsFieldResolver interface {
	// EnvVars implements response to request for envVars field.
	EnvVars(p graphql.ResolveParams) ([]string, error)
}

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

// CheckHandlersFieldResolver implement to resolve requests for the Check's handlers field.
type CheckHandlersFieldResolver interface {
	// Handlers implements response to request for handlers field.
	Handlers(p graphql.ResolveParams) (interface{}, error)
}

// CheckHighFlapThresholdFieldResolver implement to resolve requests for the Check's highFlapThreshold field.
type CheckHighFlapThresholdFieldResolver interface {
	// HighFlapThreshold implements response to request for highFlapThreshold field.
	HighFlapThreshold(p graphql.ResolveParams) (int, error)
}

// CheckIntervalFieldResolver implement to resolve requests for the Check's interval field.
type CheckIntervalFieldResolver interface {
	// Interval implements response to request for interval field.
	Interval(p graphql.ResolveParams) (int, error)
}

// CheckCronFieldResolver implement to resolve requests for the Check's cron field.
type CheckCronFieldResolver interface {
	// Cron implements response to request for cron field.
	Cron(p graphql.ResolveParams) (string, error)
}

// CheckLowFlapThresholdFieldResolver implement to resolve requests for the Check's lowFlapThreshold field.
type CheckLowFlapThresholdFieldResolver interface {
	// LowFlapThreshold implements response to request for lowFlapThreshold field.
	LowFlapThreshold(p graphql.ResolveParams) (int, error)
}

// CheckOutputMetricFormatFieldResolver implement to resolve requests for the Check's outputMetricFormat field.
type CheckOutputMetricFormatFieldResolver interface {
	// OutputMetricFormat implements response to request for outputMetricFormat field.
	OutputMetricFormat(p graphql.ResolveParams) (string, error)
}

// CheckOutputMetricHandlersFieldResolver implement to resolve requests for the Check's outputMetricHandlers field.
type CheckOutputMetricHandlersFieldResolver interface {
	// OutputMetricHandlers implements response to request for outputMetricHandlers field.
	OutputMetricHandlers(p graphql.ResolveParams) (interface{}, error)
}

// CheckProxyEntityNameFieldResolver implement to resolve requests for the Check's proxyEntityName field.
type CheckProxyEntityNameFieldResolver interface {
	// ProxyEntityName implements response to request for proxyEntityName field.
	ProxyEntityName(p graphql.ResolveParams) (string, error)
}

// CheckProxyRequestsFieldResolver implement to resolve requests for the Check's proxyRequests field.
type CheckProxyRequestsFieldResolver interface {
	// ProxyRequests implements response to request for proxyRequests field.
	ProxyRequests(p graphql.ResolveParams) (interface{}, error)
}

// CheckPublishFieldResolver implement to resolve requests for the Check's publish field.
type CheckPublishFieldResolver interface {
	// Publish implements response to request for publish field.
	Publish(p graphql.ResolveParams) (bool, error)
}

// CheckRuntimeAssetsFieldResolver implement to resolve requests for the Check's runtimeAssets field.
type CheckRuntimeAssetsFieldResolver interface {
	// RuntimeAssets implements response to request for runtimeAssets field.
	RuntimeAssets(p graphql.ResolveParams) (interface{}, error)
}

// CheckRoundRobinFieldResolver implement to resolve requests for the Check's roundRobin field.
type CheckRoundRobinFieldResolver interface {
	// RoundRobin implements response to request for roundRobin field.
	RoundRobin(p graphql.ResolveParams) (bool, error)
}

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

// CheckStdinFieldResolver implement to resolve requests for the Check's stdin field.
type CheckStdinFieldResolver interface {
	// Stdin implements response to request for stdin field.
	Stdin(p graphql.ResolveParams) (bool, error)
}

// CheckSubdueFieldResolver implement to resolve requests for the Check's subdue field.
type CheckSubdueFieldResolver interface {
	// Subdue implements response to request for subdue field.
	Subdue(p graphql.ResolveParams) (interface{}, error)
}

// CheckDurationFieldResolver implement to resolve requests for the Check's duration field.
type CheckDurationFieldResolver interface {
	// Duration implements response to request for duration field.
	Duration(p graphql.ResolveParams) (float64, error)
}

// CheckExecutedFieldResolver implement to resolve requests for the Check's executed field.
type CheckExecutedFieldResolver interface {
	// Executed implements response to request for executed field.
	Executed(p graphql.ResolveParams) (time.Time, error)
}

// CheckHistoryFieldResolverArgs contains arguments provided to history when selected
type CheckHistoryFieldResolverArgs struct {
	First int // First - self descriptive
}

// CheckHistoryFieldResolverParams contains contextual info to resolve history field
type CheckHistoryFieldResolverParams struct {
	graphql.ResolveParams
	Args CheckHistoryFieldResolverArgs
}

// CheckHistoryFieldResolver implement to resolve requests for the Check's history field.
type CheckHistoryFieldResolver interface {
	// History implements response to request for history field.
	History(p CheckHistoryFieldResolverParams) (interface{}, error)
}

// CheckIssuedFieldResolver implement to resolve requests for the Check's issued field.
type CheckIssuedFieldResolver interface {
	// Issued implements response to request for issued field.
	Issued(p graphql.ResolveParams) (time.Time, error)
}

// CheckOutputFieldResolver implement to resolve requests for the Check's output field.
type CheckOutputFieldResolver interface {
	// Output implements response to request for output field.
	Output(p graphql.ResolveParams) (string, error)
}

// CheckStateFieldResolver implement to resolve requests for the Check's state field.
type CheckStateFieldResolver interface {
	// State implements response to request for state field.
	State(p graphql.ResolveParams) (string, error)
}

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

// CheckTotalStateChangeFieldResolver implement to resolve requests for the Check's totalStateChange field.
type CheckTotalStateChangeFieldResolver interface {
	// TotalStateChange implements response to request for totalStateChange field.
	TotalStateChange(p graphql.ResolveParams) (int, error)
}

// CheckHooksFieldResolver implement to resolve requests for the Check's hooks field.
type CheckHooksFieldResolver interface {
	// Hooks implements response to request for hooks field.
	Hooks(p graphql.ResolveParams) (interface{}, error)
}

// CheckSilencedFieldResolver implement to resolve requests for the Check's silenced field.
type CheckSilencedFieldResolver interface {
	// Silenced implements response to request for silenced field.
	Silenced(p graphql.ResolveParams) ([]string, error)
}

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

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

// CheckLastOKFieldResolver implement to resolve requests for the Check's lastOK field.
type CheckLastOKFieldResolver interface {
	// LastOK implements response to request for lastOK field.
	LastOK(p graphql.ResolveParams) (*time.Time, error)
}

// CheckOccurrencesFieldResolver implement to resolve requests for the Check's occurrences field.
type CheckOccurrencesFieldResolver interface {
	// Occurrences implements response to request for occurrences field.
	Occurrences(p graphql.ResolveParams) (int, error)
}

// CheckOccurrencesWatermarkFieldResolver implement to resolve requests for the Check's occurrencesWatermark field.
type CheckOccurrencesWatermarkFieldResolver interface {
	// OccurrencesWatermark implements response to request for occurrencesWatermark field.
	OccurrencesWatermark(p graphql.ResolveParams) (int, error)
}

// CheckTimeoutFieldResolver implement to resolve requests for the Check's timeout field.
type CheckTimeoutFieldResolver interface {
	// Timeout implements response to request for timeout field.
	Timeout(p graphql.ResolveParams) (int, error)
}

// CheckTtlFieldResolver implement to resolve requests for the Check's ttl field.
type CheckTtlFieldResolver interface {
	// Ttl implements response to request for ttl field.
	Ttl(p graphql.ResolveParams) (int, error)
}

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

//
// CheckFieldResolvers represents a collection of methods whose products represent the
// response values of the 'Check' 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 CheckFieldResolvers interface {
	CheckNodeIDFieldResolver
	CheckNameFieldResolver
	CheckMetadataFieldResolver
	CheckCommandFieldResolver
	CheckCheckHooksFieldResolver
	CheckEnvVarsFieldResolver
	CheckExtendedAttributesFieldResolver
	CheckHandlersFieldResolver
	CheckHighFlapThresholdFieldResolver
	CheckIntervalFieldResolver
	CheckCronFieldResolver
	CheckLowFlapThresholdFieldResolver
	CheckOutputMetricFormatFieldResolver
	CheckOutputMetricHandlersFieldResolver
	CheckProxyEntityNameFieldResolver
	CheckProxyRequestsFieldResolver
	CheckPublishFieldResolver
	CheckRuntimeAssetsFieldResolver
	CheckRoundRobinFieldResolver
	CheckSubscriptionsFieldResolver
	CheckStdinFieldResolver
	CheckSubdueFieldResolver
	CheckDurationFieldResolver
	CheckExecutedFieldResolver
	CheckHistoryFieldResolver
	CheckIssuedFieldResolver
	CheckOutputFieldResolver
	CheckStateFieldResolver
	CheckStatusFieldResolver
	CheckTotalStateChangeFieldResolver
	CheckHooksFieldResolver
	CheckSilencedFieldResolver
	CheckIsSilencedFieldResolver
	CheckSilencesFieldResolver
	CheckLastOKFieldResolver
	CheckOccurrencesFieldResolver
	CheckOccurrencesWatermarkFieldResolver
	CheckTimeoutFieldResolver
	CheckTtlFieldResolver
	CheckToJSONFieldResolver
}

// CheckAliases implements all methods on CheckFieldResolvers 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 CheckAliases struct{}

// NodeID implements response to request for 'nodeId' field.
func (_ CheckAliases) NodeID(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 'nodeId'")
	}
	return ret, err
}

// Name implements response to request for 'name' field.
func (_ CheckAliases) 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
}

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

// Command implements response to request for 'command' field.
func (_ CheckAliases) Command(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 'command'")
	}
	return ret, err
}

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

// EnvVars implements response to request for 'envVars' field.
func (_ CheckAliases) EnvVars(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 'envVars'")
	}
	return ret, err
}

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

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

// HighFlapThreshold implements response to request for 'highFlapThreshold' field.
func (_ CheckAliases) HighFlapThreshold(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'highFlapThreshold'")
	}
	return ret, err
}

// Interval implements response to request for 'interval' field.
func (_ CheckAliases) Interval(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'interval'")
	}
	return ret, err
}

// Cron implements response to request for 'cron' field.
func (_ CheckAliases) Cron(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 'cron'")
	}
	return ret, err
}

// LowFlapThreshold implements response to request for 'lowFlapThreshold' field.
func (_ CheckAliases) LowFlapThreshold(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'lowFlapThreshold'")
	}
	return ret, err
}

// OutputMetricFormat implements response to request for 'outputMetricFormat' field.
func (_ CheckAliases) OutputMetricFormat(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 'outputMetricFormat'")
	}
	return ret, err
}

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

// ProxyEntityName implements response to request for 'proxyEntityName' field.
func (_ CheckAliases) ProxyEntityName(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 'proxyEntityName'")
	}
	return ret, err
}

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

// Publish implements response to request for 'publish' field.
func (_ CheckAliases) Publish(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 'publish'")
	}
	return ret, err
}

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

// RoundRobin implements response to request for 'roundRobin' field.
func (_ CheckAliases) RoundRobin(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 'roundRobin'")
	}
	return ret, err
}

// Subscriptions implements response to request for 'subscriptions' field.
func (_ CheckAliases) 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
}

// Stdin implements response to request for 'stdin' field.
func (_ CheckAliases) Stdin(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 'stdin'")
	}
	return ret, err
}

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

// Duration implements response to request for 'duration' field.
func (_ CheckAliases) Duration(p graphql.ResolveParams) (float64, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Float.ParseValue(val).(float64)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'duration'")
	}
	return ret, err
}

// Executed implements response to request for 'executed' field.
func (_ CheckAliases) Executed(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 'executed'")
	}
	return ret, err
}

// History implements response to request for 'history' field.
func (_ CheckAliases) History(p CheckHistoryFieldResolverParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// Issued implements response to request for 'issued' field.
func (_ CheckAliases) Issued(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 'issued'")
	}
	return ret, err
}

// Output implements response to request for 'output' field.
func (_ CheckAliases) Output(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 'output'")
	}
	return ret, err
}

// State implements response to request for 'state' field.
func (_ CheckAliases) State(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 'state'")
	}
	return ret, err
}

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

// TotalStateChange implements response to request for 'totalStateChange' field.
func (_ CheckAliases) TotalStateChange(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'totalStateChange'")
	}
	return ret, err
}

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

// Silenced implements response to request for 'silenced' field.
func (_ CheckAliases) Silenced(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 'silenced'")
	}
	return ret, err
}

// IsSilenced implements response to request for 'isSilenced' field.
func (_ CheckAliases) 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 (_ CheckAliases) Silences(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

// LastOK implements response to request for 'lastOK' field.
func (_ CheckAliases) LastOK(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 'lastOK'")
	}
	return ret, err
}

// Occurrences implements response to request for 'occurrences' field.
func (_ CheckAliases) Occurrences(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'occurrences'")
	}
	return ret, err
}

// OccurrencesWatermark implements response to request for 'occurrencesWatermark' field.
func (_ CheckAliases) OccurrencesWatermark(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'occurrencesWatermark'")
	}
	return ret, err
}

// Timeout implements response to request for 'timeout' field.
func (_ CheckAliases) Timeout(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'timeout'")
	}
	return ret, err
}

// Ttl implements response to request for 'ttl' field.
func (_ CheckAliases) Ttl(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'ttl'")
	}
	return ret, err
}

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

/*
CheckType A Check is a check specification and optionally the results of the check's
execution.
*/
var CheckType = graphql.NewType("Check", graphql.ObjectKind)

// RegisterCheck registers Check object type with given service.
func RegisterCheck(svc *graphql.Service, impl CheckFieldResolvers) {
	svc.RegisterObject(_ObjectTypeCheckDesc, impl)
}
func _ObjTypeCheckNodeIDHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckNodeIDFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.NodeID(frp)
	}
}

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

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

func _ObjTypeCheckCommandHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckCommandFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Command(frp)
	}
}

func _ObjTypeCheckCheckHooksHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckCheckHooksFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.CheckHooks(frp)
	}
}

func _ObjTypeCheckEnvVarsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckEnvVarsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.EnvVars(frp)
	}
}

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

func _ObjTypeCheckHandlersHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckHandlersFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Handlers(frp)
	}
}

func _ObjTypeCheckHighFlapThresholdHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckHighFlapThresholdFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.HighFlapThreshold(frp)
	}
}

func _ObjTypeCheckIntervalHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckIntervalFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Interval(frp)
	}
}

func _ObjTypeCheckCronHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckCronFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Cron(frp)
	}
}

func _ObjTypeCheckLowFlapThresholdHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckLowFlapThresholdFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.LowFlapThreshold(frp)
	}
}

func _ObjTypeCheckOutputMetricFormatHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckOutputMetricFormatFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.OutputMetricFormat(frp)
	}
}

func _ObjTypeCheckOutputMetricHandlersHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckOutputMetricHandlersFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.OutputMetricHandlers(frp)
	}
}

func _ObjTypeCheckProxyEntityNameHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckProxyEntityNameFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ProxyEntityName(frp)
	}
}

func _ObjTypeCheckProxyRequestsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckProxyRequestsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ProxyRequests(frp)
	}
}

func _ObjTypeCheckPublishHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckPublishFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Publish(frp)
	}
}

func _ObjTypeCheckRuntimeAssetsHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckRuntimeAssetsFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.RuntimeAssets(frp)
	}
}

func _ObjTypeCheckRoundRobinHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckRoundRobinFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.RoundRobin(frp)
	}
}

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

func _ObjTypeCheckStdinHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckStdinFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Stdin(frp)
	}
}

func _ObjTypeCheckSubdueHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckSubdueFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Subdue(frp)
	}
}

func _ObjTypeCheckDurationHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckDurationFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Duration(frp)
	}
}

func _ObjTypeCheckExecutedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckExecutedFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Executed(frp)
	}
}

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

		return resolver.History(frp)
	}
}

func _ObjTypeCheckIssuedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckIssuedFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Issued(frp)
	}
}

func _ObjTypeCheckOutputHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckOutputFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Output(frp)
	}
}

func _ObjTypeCheckStateHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckStateFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.State(frp)
	}
}

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

func _ObjTypeCheckTotalStateChangeHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckTotalStateChangeFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.TotalStateChange(frp)
	}
}

func _ObjTypeCheckHooksHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckHooksFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Hooks(frp)
	}
}

func _ObjTypeCheckSilencedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckSilencedFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Silenced(frp)
	}
}

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

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

func _ObjTypeCheckLastOKHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckLastOKFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.LastOK(frp)
	}
}

func _ObjTypeCheckOccurrencesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckOccurrencesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Occurrences(frp)
	}
}

func _ObjTypeCheckOccurrencesWatermarkHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckOccurrencesWatermarkFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.OccurrencesWatermark(frp)
	}
}

func _ObjTypeCheckTimeoutHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckTimeoutFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Timeout(frp)
	}
}

func _ObjTypeCheckTtlHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckTtlFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Ttl(frp)
	}
}

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

func _ObjectTypeCheckConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "A Check is a check specification and optionally the results of the check's\nexecution.",
		Fields: graphql1.Fields{
			"checkHooks": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "CheckHooks is the list of check hooks for the check",
				Name:              "checkHooks",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("HookList")))),
			},
			"command": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "command is the command to be executed.",
				Name:              "command",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"cron": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Cron is the cron string at which the check should be run.",
				Name:              "cron",
				Type:              graphql1.String,
			},
			"duration": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Duration of execution",
				Name:              "duration",
				Type:              graphql1.Float,
			},
			"envVars": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "envVars is the list of environment variables to set for the check's\nexecution environment.",
				Name:              "envVars",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"executed": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Executed describes the time in which the check request was executed",
				Name:              "executed",
				Type:              graphql1.NewNonNull(graphql1.DateTime),
			},
			"extendedAttributes": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "ExtendedAttributes store serialized arbitrary JSON-encoded data",
				Name:              "extendedAttributes",
				Type:              graphql1.NewNonNull(graphql.OutputType("JSON")),
			},
			"handlers": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "handlers are the event handler for the check (incidents and/or metrics).",
				Name:              "handlers",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Handler"))),
			},
			"highFlapThreshold": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "HighFlapThreshold is the flap detection high threshold (% state change) for\nthe check. Sensu uses the same flap detection algorithm as Nagios.",
				Name:              "highFlapThreshold",
				Type:              graphql1.Int,
			},
			"history": &graphql1.Field{
				Args: graphql1.FieldConfigArgument{"first": &graphql1.ArgumentConfig{
					DefaultValue: 21,
					Description:  "self descriptive",
					Type:         graphql1.Int,
				}},
				DeprecationReason: "",
				Description:       "History is the check state history.",
				Name:              "history",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("CheckHistory"))),
			},
			"hooks": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Hooks describes the results of multiple hooks; if event is associated to hook\nexecution.",
				Name:              "hooks",
				Type:              graphql1.NewList(graphql.OutputType("Hook")),
			},
			"interval": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Interval is the interval, in seconds, at which the check should be run.",
				Name:              "interval",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"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),
			},
			"issued": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Issued describes the time in which the check request was issued",
				Name:              "issued",
				Type:              graphql1.NewNonNull(graphql1.DateTime),
			},
			"lastOK": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "LastOK displays last time this check's status was set to zero.",
				Name:              "lastOK",
				Type:              graphql1.DateTime,
			},
			"lowFlapThreshold": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "LowFlapThreshold is the flap detection low threshold (% state change) for\nthe check. Sensu uses the same flap detection algorithm as Nagios.",
				Name:              "lowFlapThreshold",
				Type:              graphql1.Int,
			},
			"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:       "name is the unique identifier for a check",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"nodeId": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "id of the check's configuration",
				Name:              "nodeId",
				Type:              graphql1.NewNonNull(graphql1.ID),
			},
			"occurrences": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Occurrences indicates the number of times an event has occurred for a\nclient/check pair with the same check status.",
				Name:              "occurrences",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"occurrencesWatermark": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "OccurrencesWatermark indicates the high water mark tracking number of\noccurrences at the current severity.",
				Name:              "occurrencesWatermark",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"output": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Output from the execution of Command",
				Name:              "output",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"outputMetricFormat": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "OutputOutputMetricFormat is the metric protocol that the check's output will be\nexpected to follow in order to be extracted.",
				Name:              "outputMetricFormat",
				Type:              graphql1.String,
			},
			"outputMetricHandlers": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "OutputOutputMetricHandlers is the list of event handlers that will respond to metrics\nthat have been extracted from the check.",
				Name:              "outputMetricHandlers",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Handler"))),
			},
			"proxyEntityName": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "proxyEntityName indicates the name of the entity representing an external resource",
				Name:              "proxyEntityName",
				Type:              graphql1.String,
			},
			"proxyRequests": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "proxyRequests represents a request to execute a proxy check.",
				Name:              "proxyRequests",
				Type:              graphql.OutputType("ProxyRequests"),
			},
			"publish": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Publish indicates if check requests are published for the check",
				Name:              "publish",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"roundRobin": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "RoundRobin enables round-robin scheduling if set true.",
				Name:              "roundRobin",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"runtimeAssets": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "RuntimeAssets are a list of assets required to execute check.",
				Name:              "runtimeAssets",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql.OutputType("Asset"))),
			},
			"silenced": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Silenced is a list of silenced entry ids (subscription and check name)",
				Name:              "silenced",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.String)),
			},
			"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")))),
			},
			"state": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "State provides handlers with more information about the state change",
				Name:              "state",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"status": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Status is the exit status code produced by the check",
				Name:              "status",
				Type:              graphql1.NewNonNull(graphql.OutputType("Uint")),
			},
			"stdin": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "STDIN indicates if the check command accepts JSON via stdin from the agent",
				Name:              "stdin",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"subdue": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Subdue represents one or more time windows when the check should be subdued.",
				Name:              "subdue",
				Type:              graphql.OutputType("TimeWindowWhen"),
			},
			"subscriptions": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Subscriptions is the list of subscribers for the check.",
				Name:              "subscriptions",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.String)),
			},
			"timeout": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Timeout is the timeout, in seconds, at which the check has to run.",
				Name:              "timeout",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
			"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")),
			},
			"totalStateChange": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "TotalStateChange indicates the total state change percentage for the\ncheck's history",
				Name:              "totalStateChange",
				Type:              graphql1.Int,
			},
			"ttl": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "TTL represents the length of time in seconds for which a check result is valid.",
				Name:              "ttl",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
		},
		Interfaces: []*graphql1.Interface{
			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 CheckFieldResolvers.")
		},
		Name: "Check",
	}
}

// describe Check's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeCheckDesc = graphql.ObjectDesc{
	Config: _ObjectTypeCheckConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"checkHooks":           _ObjTypeCheckCheckHooksHandler,
		"command":              _ObjTypeCheckCommandHandler,
		"cron":                 _ObjTypeCheckCronHandler,
		"duration":             _ObjTypeCheckDurationHandler,
		"envVars":              _ObjTypeCheckEnvVarsHandler,
		"executed":             _ObjTypeCheckExecutedHandler,
		"extendedAttributes":   _ObjTypeCheckExtendedAttributesHandler,
		"handlers":             _ObjTypeCheckHandlersHandler,
		"highFlapThreshold":    _ObjTypeCheckHighFlapThresholdHandler,
		"history":              _ObjTypeCheckHistoryHandler,
		"hooks":                _ObjTypeCheckHooksHandler,
		"interval":             _ObjTypeCheckIntervalHandler,
		"isSilenced":           _ObjTypeCheckIsSilencedHandler,
		"issued":               _ObjTypeCheckIssuedHandler,
		"lastOK":               _ObjTypeCheckLastOKHandler,
		"lowFlapThreshold":     _ObjTypeCheckLowFlapThresholdHandler,
		"metadata":             _ObjTypeCheckMetadataHandler,
		"name":                 _ObjTypeCheckNameHandler,
		"nodeId":               _ObjTypeCheckNodeIDHandler,
		"occurrences":          _ObjTypeCheckOccurrencesHandler,
		"occurrencesWatermark": _ObjTypeCheckOccurrencesWatermarkHandler,
		"output":               _ObjTypeCheckOutputHandler,
		"outputMetricFormat":   _ObjTypeCheckOutputMetricFormatHandler,
		"outputMetricHandlers": _ObjTypeCheckOutputMetricHandlersHandler,
		"proxyEntityName":      _ObjTypeCheckProxyEntityNameHandler,
		"proxyRequests":        _ObjTypeCheckProxyRequestsHandler,
		"publish":              _ObjTypeCheckPublishHandler,
		"roundRobin":           _ObjTypeCheckRoundRobinHandler,
		"runtimeAssets":        _ObjTypeCheckRuntimeAssetsHandler,
		"silenced":             _ObjTypeCheckSilencedHandler,
		"silences":             _ObjTypeCheckSilencesHandler,
		"state":                _ObjTypeCheckStateHandler,
		"status":               _ObjTypeCheckStatusHandler,
		"stdin":                _ObjTypeCheckStdinHandler,
		"subdue":               _ObjTypeCheckSubdueHandler,
		"subscriptions":        _ObjTypeCheckSubscriptionsHandler,
		"timeout":              _ObjTypeCheckTimeoutHandler,
		"toJSON":               _ObjTypeCheckToJSONHandler,
		"totalStateChange":     _ObjTypeCheckTotalStateChangeHandler,
		"ttl":                  _ObjTypeCheckTtlHandler,
	},
}

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

// CheckHistoryExecutedFieldResolver implement to resolve requests for the CheckHistory's executed field.
type CheckHistoryExecutedFieldResolver interface {
	// Executed implements response to request for executed field.
	Executed(p graphql.ResolveParams) (time.Time, error)
}

//
// CheckHistoryFieldResolvers represents a collection of methods whose products represent the
// response values of the 'CheckHistory' 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 CheckHistoryFieldResolvers interface {
	CheckHistoryStatusFieldResolver
	CheckHistoryExecutedFieldResolver
}

// CheckHistoryAliases implements all methods on CheckHistoryFieldResolvers 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 CheckHistoryAliases struct{}

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

// Executed implements response to request for 'executed' field.
func (_ CheckHistoryAliases) Executed(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 'executed'")
	}
	return ret, err
}

// CheckHistoryType CheckHistory is a record of a check execution and its status
var CheckHistoryType = graphql.NewType("CheckHistory", graphql.ObjectKind)

// RegisterCheckHistory registers CheckHistory object type with given service.
func RegisterCheckHistory(svc *graphql.Service, impl CheckHistoryFieldResolvers) {
	svc.RegisterObject(_ObjectTypeCheckHistoryDesc, impl)
}
func _ObjTypeCheckHistoryStatusHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckHistoryStatusFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Status(frp)
	}
}

func _ObjTypeCheckHistoryExecutedHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckHistoryExecutedFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Executed(frp)
	}
}

func _ObjectTypeCheckHistoryConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "CheckHistory is a record of a check execution and its status",
		Fields: graphql1.Fields{
			"executed": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Executed describes the time in which the check request was executed",
				Name:              "executed",
				Type:              graphql1.NewNonNull(graphql1.DateTime),
			},
			"status": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Status is the exit status code produced by the check.",
				Name:              "status",
				Type:              graphql1.NewNonNull(graphql.OutputType("Uint")),
			},
		},
		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 CheckHistoryFieldResolvers.")
		},
		Name: "CheckHistory",
	}
}

// describe CheckHistory's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeCheckHistoryDesc = graphql.ObjectDesc{
	Config: _ObjectTypeCheckHistoryConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"executed": _ObjTypeCheckHistoryExecutedHandler,
		"status":   _ObjTypeCheckHistoryStatusHandler,
	},
}

// ProxyRequestsEntityAttributesFieldResolver implement to resolve requests for the ProxyRequests's entityAttributes field.
type ProxyRequestsEntityAttributesFieldResolver interface {
	// EntityAttributes implements response to request for entityAttributes field.
	EntityAttributes(p graphql.ResolveParams) (interface{}, error)
}

// ProxyRequestsSplayFieldResolver implement to resolve requests for the ProxyRequests's splay field.
type ProxyRequestsSplayFieldResolver interface {
	// Splay implements response to request for splay field.
	Splay(p graphql.ResolveParams) (bool, error)
}

// ProxyRequestsSplayCoverageFieldResolver implement to resolve requests for the ProxyRequests's splayCoverage field.
type ProxyRequestsSplayCoverageFieldResolver interface {
	// SplayCoverage implements response to request for splayCoverage field.
	SplayCoverage(p graphql.ResolveParams) (int, error)
}

//
// ProxyRequestsFieldResolvers represents a collection of methods whose products represent the
// response values of the 'ProxyRequests' 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 ProxyRequestsFieldResolvers interface {
	ProxyRequestsEntityAttributesFieldResolver
	ProxyRequestsSplayFieldResolver
	ProxyRequestsSplayCoverageFieldResolver
}

// ProxyRequestsAliases implements all methods on ProxyRequestsFieldResolvers 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 ProxyRequestsAliases struct{}

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

// Splay implements response to request for 'splay' field.
func (_ ProxyRequestsAliases) Splay(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 'splay'")
	}
	return ret, err
}

// SplayCoverage implements response to request for 'splayCoverage' field.
func (_ ProxyRequestsAliases) SplayCoverage(p graphql.ResolveParams) (int, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	ret, ok := graphql1.Int.ParseValue(val).(int)
	if err != nil {
		return ret, err
	}
	if !ok {
		return ret, errors.New("unable to coerce value for field 'splayCoverage'")
	}
	return ret, err
}

// ProxyRequestsType A ProxyRequests represents a request to execute a proxy check.
var ProxyRequestsType = graphql.NewType("ProxyRequests", graphql.ObjectKind)

// RegisterProxyRequests registers ProxyRequests object type with given service.
func RegisterProxyRequests(svc *graphql.Service, impl ProxyRequestsFieldResolvers) {
	svc.RegisterObject(_ObjectTypeProxyRequestsDesc, impl)
}
func _ObjTypeProxyRequestsEntityAttributesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ProxyRequestsEntityAttributesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.EntityAttributes(frp)
	}
}

func _ObjTypeProxyRequestsSplayHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ProxyRequestsSplayFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Splay(frp)
	}
}

func _ObjTypeProxyRequestsSplayCoverageHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(ProxyRequestsSplayCoverageFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.SplayCoverage(frp)
	}
}

func _ObjectTypeProxyRequestsConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "A ProxyRequests represents a request to execute a proxy check.",
		Fields: graphql1.Fields{
			"entityAttributes": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "entityAttributes store serialized arbitrary JSON-encoded data to match\nentities in the registry.",
				Name:              "entityAttributes",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("JSON")))),
			},
			"splay": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "splay indicates if proxy check requests should be splayed, published evenly\nover a window of time.",
				Name:              "splay",
				Type:              graphql1.NewNonNull(graphql1.Boolean),
			},
			"splayCoverage": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "splayCoverage is the percentage used for proxy check request splay\ncalculation.",
				Name:              "splayCoverage",
				Type:              graphql1.NewNonNull(graphql1.Int),
			},
		},
		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 ProxyRequestsFieldResolvers.")
		},
		Name: "ProxyRequests",
	}
}

// describe ProxyRequests's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeProxyRequestsDesc = graphql.ObjectDesc{
	Config: _ObjectTypeProxyRequestsConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"entityAttributes": _ObjTypeProxyRequestsEntityAttributesHandler,
		"splay":            _ObjTypeProxyRequestsSplayHandler,
		"splayCoverage":    _ObjTypeProxyRequestsSplayCoverageHandler,
	},
}

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

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

//
// CheckConfigConnectionFieldResolvers represents a collection of methods whose products represent the
// response values of the 'CheckConfigConnection' 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 CheckConfigConnectionFieldResolvers interface {
	CheckConfigConnectionNodesFieldResolver
	CheckConfigConnectionPageInfoFieldResolver
}

// CheckConfigConnectionAliases implements all methods on CheckConfigConnectionFieldResolvers 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 CheckConfigConnectionAliases struct{}

// Nodes implements response to request for 'nodes' field.
func (_ CheckConfigConnectionAliases) 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 (_ CheckConfigConnectionAliases) PageInfo(p graphql.ResolveParams) (interface{}, error) {
	val, err := graphql.DefaultResolver(p.Source, p.Info.FieldName)
	return val, err
}

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

// RegisterCheckConfigConnection registers CheckConfigConnection object type with given service.
func RegisterCheckConfigConnection(svc *graphql.Service, impl CheckConfigConnectionFieldResolvers) {
	svc.RegisterObject(_ObjectTypeCheckConfigConnectionDesc, impl)
}
func _ObjTypeCheckConfigConnectionNodesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(CheckConfigConnectionNodesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Nodes(frp)
	}
}

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

func _ObjectTypeCheckConfigConnectionConfigFn() 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("CheckConfig")))),
			},
			"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 CheckConfigConnectionFieldResolvers.")
		},
		Name: "CheckConfigConnection",
	}
}

// describe CheckConfigConnection's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeCheckConfigConnectionDesc = graphql.ObjectDesc{
	Config: _ObjectTypeCheckConfigConnectionConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"nodes":    _ObjTypeCheckConfigConnectionNodesHandler,
		"pageInfo": _ObjTypeCheckConfigConnectionPageInfoHandler,
	},
}

// CheckListOrder Describes ways in which a list of checks can be ordered.
type CheckListOrder string

// CheckListOrders holds enum values
var CheckListOrders = _EnumTypeCheckListOrderValues{
	NAME:      "NAME",
	NAME_DESC: "NAME_DESC",
}

// CheckListOrderType Describes ways in which a list of checks can be ordered.
var CheckListOrderType = graphql.NewType("CheckListOrder", graphql.EnumKind)

// RegisterCheckListOrder registers CheckListOrder object type with given service.
func RegisterCheckListOrder(svc *graphql.Service) {
	svc.RegisterEnum(_EnumTypeCheckListOrderDesc)
}
func _EnumTypeCheckListOrderConfigFn() graphql1.EnumConfig {
	return graphql1.EnumConfig{
		Description: "Describes ways in which a list of checks can be ordered.",
		Name:        "CheckListOrder",
		Values: graphql1.EnumValueConfigMap{
			"NAME": &graphql1.EnumValueConfig{
				DeprecationReason: "",
				Description:       "self descriptive",
				Value:             "NAME",
			},
			"NAME_DESC": &graphql1.EnumValueConfig{
				DeprecationReason: "",
				Description:       "self descriptive",
				Value:             "NAME_DESC",
			},
		},
	}
}

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

type _EnumTypeCheckListOrderValues struct {
	// NAME - self descriptive
	NAME CheckListOrder
	// NAME_DESC - self descriptive
	NAME_DESC CheckListOrder
}