graphql/schema/handler.gql.go

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

package schema

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

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

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

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

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

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

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

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

// HandlerSocketFieldResolver implement to resolve requests for the Handler's socket field.
type HandlerSocketFieldResolver interface {
	// Socket implements response to request for socket field.
	Socket(p graphql.ResolveParams) (interface{}, error)
}

// HandlerMutatorFieldResolver implement to resolve requests for the Handler's mutator field.
type HandlerMutatorFieldResolver interface {
	// Mutator implements response to request for mutator field.
	Mutator(p graphql.ResolveParams) (interface{}, error)
}

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

// HandlerFiltersFieldResolver implement to resolve requests for the Handler's filters field.
type HandlerFiltersFieldResolver interface {
	// Filters implements response to request for filters field.
	Filters(p graphql.ResolveParams) ([]string, error)
}

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

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

//
// HandlerFieldResolvers represents a collection of methods whose products represent the
// response values of the 'Handler' 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 HandlerFieldResolvers interface {
	HandlerIDFieldResolver
	HandlerNamespaceFieldResolver
	HandlerNameFieldResolver
	HandlerMetadataFieldResolver
	HandlerTypeFieldResolver
	HandlerCommandFieldResolver
	HandlerTimeoutFieldResolver
	HandlerSocketFieldResolver
	HandlerMutatorFieldResolver
	HandlerHandlersFieldResolver
	HandlerFiltersFieldResolver
	HandlerEnvVarsFieldResolver
	HandlerToJSONFieldResolver
}

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

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

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

// Command implements response to request for 'command' field.
func (_ HandlerAliases) 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
}

// Timeout implements response to request for 'timeout' field.
func (_ HandlerAliases) 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
}

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

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

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

// EnvVars implements response to request for 'envVars' field.
func (_ HandlerAliases) 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
}

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

// HandlerType A Handler is a handler specification.
var HandlerType = graphql.NewType("Handler", graphql.ObjectKind)

// RegisterHandler registers Handler object type with given service.
func RegisterHandler(svc *graphql.Service, impl HandlerFieldResolvers) {
	svc.RegisterObject(_ObjectTypeHandlerDesc, impl)
}
func _ObjTypeHandlerIDHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerIDFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.ID(frp)
	}
}

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

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

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

func _ObjTypeHandlerTypeHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerTypeFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Type(frp)
	}
}

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

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

func _ObjTypeHandlerSocketHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerSocketFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Socket(frp)
	}
}

func _ObjTypeHandlerMutatorHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerMutatorFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Mutator(frp)
	}
}

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

func _ObjTypeHandlerFiltersHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerFiltersFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Filters(frp)
	}
}

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

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

func _ObjectTypeHandlerConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "A Handler is a handler specification.",
		Fields: graphql1.Fields{
			"command": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Command is the command to be executed for a pipe handler.",
				Name:              "command",
				Type:              graphql1.String,
			},
			"envVars": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "EnvVars is a list of environment variables to use with command execution",
				Name:              "envVars",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"filters": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Filters is a list of filters name to evaluate before executing this handler",
				Name:              "filters",
				Type:              graphql1.NewNonNull(graphql1.NewList(graphql1.NewNonNull(graphql1.String))),
			},
			"handlers": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Handlers is a list of handler names for a handler set.",
				Name:              "handlers",
				Type:              graphql1.NewList(graphql1.NewNonNull(graphql.OutputType("Handler"))),
			},
			"id": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "The globally unique identifier of the record.",
				Name:              "id",
				Type:              graphql1.NewNonNull(graphql1.ID),
			},
			"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")),
			},
			"mutator": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Mutator is the handler event data mutator.",
				Name:              "mutator",
				Type:              graphql.OutputType("Mutator"),
			},
			"name": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Name is the unique identifier for a handler.",
				Name:              "name",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"namespace": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "namespace in which this record resides",
				Name:              "namespace",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"socket": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Socket contains configuration for a TCP or UDP handler.",
				Name:              "socket",
				Type:              graphql.OutputType("HandlerSocket"),
			},
			"timeout": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Timeout is the handler timeout in seconds.",
				Name:              "timeout",
				Type:              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")),
			},
			"type": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Type is the handler type, i.e. pipe.",
				Name:              "type",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
		},
		Interfaces: []*graphql1.Interface{
			graphql.Interface("Node"),
			graphql.Interface("Namespaced"),
			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 HandlerFieldResolvers.")
		},
		Name: "Handler",
	}
}

// describe Handler's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeHandlerDesc = graphql.ObjectDesc{
	Config: _ObjectTypeHandlerConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"command":   _ObjTypeHandlerCommandHandler,
		"envVars":   _ObjTypeHandlerEnvVarsHandler,
		"filters":   _ObjTypeHandlerFiltersHandler,
		"handlers":  _ObjTypeHandlerHandlersHandler,
		"id":        _ObjTypeHandlerIDHandler,
		"metadata":  _ObjTypeHandlerMetadataHandler,
		"mutator":   _ObjTypeHandlerMutatorHandler,
		"name":      _ObjTypeHandlerNameHandler,
		"namespace": _ObjTypeHandlerNamespaceHandler,
		"socket":    _ObjTypeHandlerSocketHandler,
		"timeout":   _ObjTypeHandlerTimeoutHandler,
		"toJSON":    _ObjTypeHandlerToJSONHandler,
		"type":      _ObjTypeHandlerTypeHandler,
	},
}

// HandlerSocketHostFieldResolver implement to resolve requests for the HandlerSocket's host field.
type HandlerSocketHostFieldResolver interface {
	// Host implements response to request for host field.
	Host(p graphql.ResolveParams) (string, error)
}

// HandlerSocketPortFieldResolver implement to resolve requests for the HandlerSocket's port field.
type HandlerSocketPortFieldResolver interface {
	// Port implements response to request for port field.
	Port(p graphql.ResolveParams) (int, error)
}

//
// HandlerSocketFieldResolvers represents a collection of methods whose products represent the
// response values of the 'HandlerSocket' 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 HandlerSocketFieldResolvers interface {
	HandlerSocketHostFieldResolver
	HandlerSocketPortFieldResolver
}

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

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

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

// HandlerSocketType HandlerSocket contains configuration for a TCP or UDP handler.
var HandlerSocketType = graphql.NewType("HandlerSocket", graphql.ObjectKind)

// RegisterHandlerSocket registers HandlerSocket object type with given service.
func RegisterHandlerSocket(svc *graphql.Service, impl HandlerSocketFieldResolvers) {
	svc.RegisterObject(_ObjectTypeHandlerSocketDesc, impl)
}
func _ObjTypeHandlerSocketHostHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerSocketHostFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Host(frp)
	}
}

func _ObjTypeHandlerSocketPortHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerSocketPortFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Port(frp)
	}
}

func _ObjectTypeHandlerSocketConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "HandlerSocket contains configuration for a TCP or UDP handler.",
		Fields: graphql1.Fields{
			"host": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Host is the socket peer address.",
				Name:              "host",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"port": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "Port is the socket peer port.",
				Name:              "port",
				Type:              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 HandlerSocketFieldResolvers.")
		},
		Name: "HandlerSocket",
	}
}

// describe HandlerSocket's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeHandlerSocketDesc = graphql.ObjectDesc{
	Config: _ObjectTypeHandlerSocketConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"host": _ObjTypeHandlerSocketHostHandler,
		"port": _ObjTypeHandlerSocketPortHandler,
	},
}

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

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

//
// HandlerConnectionFieldResolvers represents a collection of methods whose products represent the
// response values of the 'HandlerConnection' 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 HandlerConnectionFieldResolvers interface {
	HandlerConnectionNodesFieldResolver
	HandlerConnectionPageInfoFieldResolver
}

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

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

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

// RegisterHandlerConnection registers HandlerConnection object type with given service.
func RegisterHandlerConnection(svc *graphql.Service, impl HandlerConnectionFieldResolvers) {
	svc.RegisterObject(_ObjectTypeHandlerConnectionDesc, impl)
}
func _ObjTypeHandlerConnectionNodesHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerConnectionNodesFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Nodes(frp)
	}
}

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

func _ObjectTypeHandlerConnectionConfigFn() 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("Handler")))),
			},
			"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 HandlerConnectionFieldResolvers.")
		},
		Name: "HandlerConnection",
	}
}

// describe HandlerConnection's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeHandlerConnectionDesc = graphql.ObjectDesc{
	Config: _ObjectTypeHandlerConnectionConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"nodes":    _ObjTypeHandlerConnectionNodesHandler,
		"pageInfo": _ObjTypeHandlerConnectionPageInfoHandler,
	},
}

// HandlerEdgeNodeFieldResolver implement to resolve requests for the HandlerEdge's node field.
type HandlerEdgeNodeFieldResolver interface {
	// Node implements response to request for node field.
	Node(p graphql.ResolveParams) (interface{}, error)
}

// HandlerEdgeCursorFieldResolver implement to resolve requests for the HandlerEdge's cursor field.
type HandlerEdgeCursorFieldResolver interface {
	// Cursor implements response to request for cursor field.
	Cursor(p graphql.ResolveParams) (string, error)
}

//
// HandlerEdgeFieldResolvers represents a collection of methods whose products represent the
// response values of the 'HandlerEdge' 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 HandlerEdgeFieldResolvers interface {
	HandlerEdgeNodeFieldResolver
	HandlerEdgeCursorFieldResolver
}

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

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

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

// HandlerEdgeType An edge in a connection.
var HandlerEdgeType = graphql.NewType("HandlerEdge", graphql.ObjectKind)

// RegisterHandlerEdge registers HandlerEdge object type with given service.
func RegisterHandlerEdge(svc *graphql.Service, impl HandlerEdgeFieldResolvers) {
	svc.RegisterObject(_ObjectTypeHandlerEdgeDesc, impl)
}
func _ObjTypeHandlerEdgeNodeHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerEdgeNodeFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Node(frp)
	}
}

func _ObjTypeHandlerEdgeCursorHandler(impl interface{}) graphql1.FieldResolveFn {
	resolver := impl.(HandlerEdgeCursorFieldResolver)
	return func(frp graphql1.ResolveParams) (interface{}, error) {
		return resolver.Cursor(frp)
	}
}

func _ObjectTypeHandlerEdgeConfigFn() graphql1.ObjectConfig {
	return graphql1.ObjectConfig{
		Description: "An edge in a connection.",
		Fields: graphql1.Fields{
			"cursor": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "cursor",
				Type:              graphql1.NewNonNull(graphql1.String),
			},
			"node": &graphql1.Field{
				Args:              graphql1.FieldConfigArgument{},
				DeprecationReason: "",
				Description:       "self descriptive",
				Name:              "node",
				Type:              graphql.OutputType("Handler"),
			},
		},
		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 HandlerEdgeFieldResolvers.")
		},
		Name: "HandlerEdge",
	}
}

// describe HandlerEdge's configuration; kept private to avoid unintentional tampering of configuration at runtime.
var _ObjectTypeHandlerEdgeDesc = graphql.ObjectDesc{
	Config: _ObjectTypeHandlerEdgeConfigFn,
	FieldHandlers: map[string]graphql.FieldHandler{
		"cursor": _ObjTypeHandlerEdgeCursorHandler,
		"node":   _ObjTypeHandlerEdgeNodeHandler,
	},
}

// HandlerListOrder Describes ways in which a list of handlers can be ordered.
type HandlerListOrder string

// HandlerListOrders holds enum values
var HandlerListOrders = _EnumTypeHandlerListOrderValues{
	NAME:      "NAME",
	NAME_DESC: "NAME_DESC",
}

// HandlerListOrderType Describes ways in which a list of handlers can be ordered.
var HandlerListOrderType = graphql.NewType("HandlerListOrder", graphql.EnumKind)

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

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

type _EnumTypeHandlerListOrderValues struct {
	// NAME - self descriptive
	NAME HandlerListOrder
	// NAME_DESC - self descriptive
	NAME_DESC HandlerListOrder
}