func (w *Walker) AddDocumentLeaveEventHandler(h DocumentEventHandler) {
	w.documentEventHandlers.leave = append(w.documentEventHandlers.leave, h)
}
AddDocumentLeaveEventHandler adds an event handler to be called when leaving Document nodes.
package validation
import "github.com/bucketd/go-graphqlparser/ast"
type Walker struct {
	argumentEventHandlers                        ArgumentEventHandlers
	argumentsEventHandlers                       ArgumentsEventHandlers
	booleanValueEventHandlers                    BooleanValueEventHandlers
	definitionEventHandlers                      DefinitionEventHandlers
	definitionsEventHandlers                     DefinitionsEventHandlers
	directiveEventHandlers                       DirectiveEventHandlers
	directiveDefinitionEventHandlers             DirectiveDefinitionEventHandlers
	directivesEventHandlers                      DirectivesEventHandlers
	documentEventHandlers                        DocumentEventHandlers
	enumTypeDefinitionEventHandlers              EnumTypeDefinitionEventHandlers
	enumTypeExtensionEventHandlers               EnumTypeExtensionEventHandlers
	enumValueEventHandlers                       EnumValueEventHandlers
	enumValueDefinitionEventHandlers             EnumValueDefinitionEventHandlers
	enumValueDefinitionsEventHandlers            EnumValueDefinitionsEventHandlers
	executableDefinitionEventHandlers            ExecutableDefinitionEventHandlers
	fieldDefinitionEventHandlers                 FieldDefinitionEventHandlers
	fieldDefinitionsEventHandlers                FieldDefinitionsEventHandlers
	fieldSelectionEventHandlers                  FieldSelectionEventHandlers
	floatValueEventHandlers                      FloatValueEventHandlers
	fragmentDefinitionEventHandlers              FragmentDefinitionEventHandlers
	fragmentSpreadSelectionEventHandlers         FragmentSpreadSelectionEventHandlers
	inlineFragmentSelectionEventHandlers         InlineFragmentSelectionEventHandlers
	inputObjectTypeDefinitionEventHandlers       InputObjectTypeDefinitionEventHandlers
	inputObjectTypeExtensionEventHandlers        InputObjectTypeExtensionEventHandlers
	inputValueDefinitionEventHandlers            InputValueDefinitionEventHandlers
	inputValueDefinitionsEventHandlers           InputValueDefinitionsEventHandlers
	intPathNodeEventHandlers                     IntPathNodeEventHandlers
	intValueEventHandlers                        IntValueEventHandlers
	interfaceTypeDefinitionEventHandlers         InterfaceTypeDefinitionEventHandlers
	interfaceTypeExtensionEventHandlers          InterfaceTypeExtensionEventHandlers
	listTypeEventHandlers                        ListTypeEventHandlers
	listValueEventHandlers                       ListValueEventHandlers
	locationEventHandlers                        LocationEventHandlers
	locationsEventHandlers                       LocationsEventHandlers
	mutationOperationDefinitionEventHandlers     MutationOperationDefinitionEventHandlers
	namedTypeEventHandlers                       NamedTypeEventHandlers
	nullValueEventHandlers                       NullValueEventHandlers
	objectFieldEventHandlers                     ObjectFieldEventHandlers
	objectTypeDefinitionEventHandlers            ObjectTypeDefinitionEventHandlers
	objectTypeExtensionEventHandlers             ObjectTypeExtensionEventHandlers
	objectValueEventHandlers                     ObjectValueEventHandlers
	operationDefinitionEventHandlers             OperationDefinitionEventHandlers
	operationTypeDefinitionEventHandlers         OperationTypeDefinitionEventHandlers
	operationTypeDefinitionsEventHandlers        OperationTypeDefinitionsEventHandlers
	pathNodeEventHandlers                        PathNodeEventHandlers
	pathNodesEventHandlers                       PathNodesEventHandlers
	queryOperationDefinitionEventHandlers        QueryOperationDefinitionEventHandlers
	scalarTypeDefinitionEventHandlers            ScalarTypeDefinitionEventHandlers
	scalarTypeExtensionEventHandlers             ScalarTypeExtensionEventHandlers
	schemaDefinitionEventHandlers                SchemaDefinitionEventHandlers
	schemaExtensionEventHandlers                 SchemaExtensionEventHandlers
	selectionEventHandlers                       SelectionEventHandlers
	selectionsEventHandlers                      SelectionsEventHandlers
	stringPathNodeEventHandlers                  StringPathNodeEventHandlers
	stringValueEventHandlers                     StringValueEventHandlers
	subscriptionOperationDefinitionEventHandlers SubscriptionOperationDefinitionEventHandlers
	typeEventHandlers                            TypeEventHandlers
	typeConditionEventHandlers                   TypeConditionEventHandlers
	typeDefinitionEventHandlers                  TypeDefinitionEventHandlers
	typeExtensionEventHandlers                   TypeExtensionEventHandlers
	typeSystemDefinitionEventHandlers            TypeSystemDefinitionEventHandlers
	typeSystemExtensionEventHandlers             TypeSystemExtensionEventHandlers
	typesEventHandlers                           TypesEventHandlers
	unionTypeDefinitionEventHandlers             UnionTypeDefinitionEventHandlers
	unionTypeExtensionEventHandlers              UnionTypeExtensionEventHandlers
	valueEventHandlers                           ValueEventHandlers
	variableDefinitionEventHandlers              VariableDefinitionEventHandlers
	variableDefinitionsEventHandlers             VariableDefinitionsEventHandlers
	variableValueEventHandlers                   VariableValueEventHandlers
}
func NewWalker(visitFns []VisitFunc) *Walker {
	walker := &Walker{}
	for _, visitFn := range visitFns {
		visitFn(walker)
	}
	return walker
}
func (w *Walker) Walk(ctx *Context, doc ast.Document) {
	w.walkDocument(ctx, doc)
}
type ArgumentEventHandler func(*Context, ast.Argument)
type ArgumentEventHandlers struct {
	enter []ArgumentEventHandler
	leave []ArgumentEventHandler
}
func (w *Walker) AddArgumentEnterEventHandler(h ArgumentEventHandler) {
	w.argumentEventHandlers.enter = append(w.argumentEventHandlers.enter, h)
}
func (w *Walker) AddArgumentLeaveEventHandler(h ArgumentEventHandler) {
	w.argumentEventHandlers.leave = append(w.argumentEventHandlers.leave, h)
}
func (w *Walker) OnArgumentEnter(ctx *Context, a ast.Argument) {
	for _, handler := range w.argumentEventHandlers.enter {
		handler(ctx, a)
	}
}
func (w *Walker) OnArgumentLeave(ctx *Context, a ast.Argument) {
	for _, handler := range w.argumentEventHandlers.leave {
		handler(ctx, a)
	}
}
func (w *Walker) walkArgument(ctx *Context, a ast.Argument) {
	w.OnArgumentEnter(ctx, a)
	w.walkValue(ctx, a.Value)
	w.OnArgumentLeave(ctx, a)
}
type ArgumentsEventHandler func(*Context, *ast.Arguments)
type ArgumentsEventHandlers struct {
	enter []ArgumentsEventHandler
	leave []ArgumentsEventHandler
}
func (w *Walker) AddArgumentsEnterEventHandler(h ArgumentsEventHandler) {
	w.argumentsEventHandlers.enter = append(w.argumentsEventHandlers.enter, h)
}
func (w *Walker) AddArgumentsLeaveEventHandler(h ArgumentsEventHandler) {
	w.argumentsEventHandlers.leave = append(w.argumentsEventHandlers.leave, h)
}
func (w *Walker) OnArgumentsEnter(ctx *Context, as *ast.Arguments) {
	for _, handler := range w.argumentsEventHandlers.enter {
		handler(ctx, as)
	}
}
func (w *Walker) OnArgumentsLeave(ctx *Context, as *ast.Arguments) {
	for _, handler := range w.argumentsEventHandlers.leave {
		handler(ctx, as)
	}
}
func (w *Walker) walkArguments(ctx *Context, as *ast.Arguments) {
	w.OnArgumentsEnter(ctx, as)
	as.ForEach(func(a ast.Argument, i int) {
		w.walkArgument(ctx, a)
	})
	w.OnArgumentsLeave(ctx, as)
}
type BooleanValueEventHandler func(*Context, ast.Value)
type BooleanValueEventHandlers struct {
	enter []BooleanValueEventHandler
	leave []BooleanValueEventHandler
}
func (w *Walker) AddBooleanValueEnterEventHandler(h BooleanValueEventHandler) {
	w.booleanValueEventHandlers.enter = append(w.booleanValueEventHandlers.enter, h)
}
func (w *Walker) AddBooleanValueLeaveEventHandler(h BooleanValueEventHandler) {
	w.booleanValueEventHandlers.leave = append(w.booleanValueEventHandlers.leave, h)
}
func (w *Walker) OnBooleanValueEnter(ctx *Context, v ast.Value) {
	for _, handler := range w.booleanValueEventHandlers.enter {
		handler(ctx, v)
	}
}
func (w *Walker) OnBooleanValueLeave(ctx *Context, v ast.Value) {
	for _, handler := range w.booleanValueEventHandlers.leave {
		handler(ctx, v)
	}
}
func (w *Walker) walkBooleanValue(ctx *Context, v ast.Value) {
	w.OnBooleanValueEnter(ctx, v)
	w.OnBooleanValueLeave(ctx, v)
}
type DefinitionEventHandler func(*Context, ast.Definition)
type DefinitionEventHandlers struct {
	enter []DefinitionEventHandler
	leave []DefinitionEventHandler
}
func (w *Walker) AddDefinitionEnterEventHandler(h DefinitionEventHandler) {
	w.definitionEventHandlers.enter = append(w.definitionEventHandlers.enter, h)
}
func (w *Walker) AddDefinitionLeaveEventHandler(h DefinitionEventHandler) {
	w.definitionEventHandlers.leave = append(w.definitionEventHandlers.leave, h)
}
func (w *Walker) OnDefinitionEnter(ctx *Context, d ast.Definition) {
	for _, handler := range w.definitionEventHandlers.enter {
		handler(ctx, d)
	}
}
func (w *Walker) OnDefinitionLeave(ctx *Context, d ast.Definition) {
	for _, handler := range w.definitionEventHandlers.leave {
		handler(ctx, d)
	}
}
func (w *Walker) walkDefinition(ctx *Context, d ast.Definition) {
	w.OnDefinitionEnter(ctx, d)
	switch d.Kind {
	case ast.DefinitionKindExecutable:
		w.walkExecutableDefinition(ctx, d.ExecutableDefinition)
	case ast.DefinitionKindTypeSystem:
		w.walkTypeSystemDefinition(ctx, d.TypeSystemDefinition)
	case ast.DefinitionKindTypeSystemExtension:
		w.walkTypeSystemExtension(ctx, d.TypeSystemExtension)
	}
	w.OnDefinitionLeave(ctx, d)
}
type DefinitionsEventHandler func(*Context, *ast.Definitions)
type DefinitionsEventHandlers struct {
	enter []DefinitionsEventHandler
	leave []DefinitionsEventHandler
}
func (w *Walker) AddDefinitionsEnterEventHandler(h DefinitionsEventHandler) {
	w.definitionsEventHandlers.enter = append(w.definitionsEventHandlers.enter, h)
}
func (w *Walker) AddDefinitionsLeaveEventHandler(h DefinitionsEventHandler) {
	w.definitionsEventHandlers.leave = append(w.definitionsEventHandlers.leave, h)
}
func (w *Walker) OnDefinitionsEnter(ctx *Context, ds *ast.Definitions) {
	for _, handler := range w.definitionsEventHandlers.enter {
		handler(ctx, ds)
	}
}
func (w *Walker) OnDefinitionsLeave(ctx *Context, ds *ast.Definitions) {
	for _, handler := range w.definitionsEventHandlers.leave {
		handler(ctx, ds)
	}
}
func (w *Walker) walkDefinitions(ctx *Context, ds *ast.Definitions) {
	w.OnDefinitionsEnter(ctx, ds)
	ds.ForEach(func(d ast.Definition, i int) {
		w.walkDefinition(ctx, d)
	})
	w.OnDefinitionsLeave(ctx, ds)
}
type DirectiveEventHandler func(*Context, ast.Directive)
type DirectiveEventHandlers struct {
	enter []DirectiveEventHandler
	leave []DirectiveEventHandler
}
func (w *Walker) AddDirectiveEnterEventHandler(h DirectiveEventHandler) {
	w.directiveEventHandlers.enter = append(w.directiveEventHandlers.enter, h)
}
func (w *Walker) AddDirectiveLeaveEventHandler(h DirectiveEventHandler) {
	w.directiveEventHandlers.leave = append(w.directiveEventHandlers.leave, h)
}
func (w *Walker) OnDirectiveEnter(ctx *Context, d ast.Directive) {
	for _, handler := range w.directiveEventHandlers.enter {
		handler(ctx, d)
	}
}
func (w *Walker) OnDirectiveLeave(ctx *Context, d ast.Directive) {
	for _, handler := range w.directiveEventHandlers.leave {
		handler(ctx, d)
	}
}
func (w *Walker) walkDirective(ctx *Context, d ast.Directive) {
	w.OnDirectiveEnter(ctx, d)
	if d.Arguments != nil {
		w.walkArguments(ctx, d.Arguments)
	}
	w.OnDirectiveLeave(ctx, d)
}
type DirectiveDefinitionEventHandler func(*Context, *ast.DirectiveDefinition)
type DirectiveDefinitionEventHandlers struct {
	enter []DirectiveDefinitionEventHandler
	leave []DirectiveDefinitionEventHandler
}
func (w *Walker) AddDirectiveDefinitionEnterEventHandler(h DirectiveDefinitionEventHandler) {
	w.directiveDefinitionEventHandlers.enter = append(w.directiveDefinitionEventHandlers.enter, h)
}
func (w *Walker) AddDirectiveDefinitionLeaveEventHandler(h DirectiveDefinitionEventHandler) {
	w.directiveDefinitionEventHandlers.leave = append(w.directiveDefinitionEventHandlers.leave, h)
}
func (w *Walker) OnDirectiveDefinitionEnter(ctx *Context, dd *ast.DirectiveDefinition) {
	for _, handler := range w.directiveDefinitionEventHandlers.enter {
		handler(ctx, dd)
	}
}
func (w *Walker) OnDirectiveDefinitionLeave(ctx *Context, dd *ast.DirectiveDefinition) {
	for _, handler := range w.directiveDefinitionEventHandlers.leave {
		handler(ctx, dd)
	}
}
func (w *Walker) walkDirectiveDefinition(ctx *Context, dd *ast.DirectiveDefinition) {
	w.OnDirectiveDefinitionEnter(ctx, dd)
	if dd.ArgumentsDefinition != nil {
		w.walkInputValueDefinitions(ctx, dd.ArgumentsDefinition)
	}
	w.OnDirectiveDefinitionLeave(ctx, dd)
}
type DirectivesEventHandler func(*Context, *ast.Directives)
type DirectivesEventHandlers struct {
	enter []DirectivesEventHandler
	leave []DirectivesEventHandler
}
func (w *Walker) AddDirectivesEnterEventHandler(h DirectivesEventHandler) {
	w.directivesEventHandlers.enter = append(w.directivesEventHandlers.enter, h)
}
func (w *Walker) AddDirectivesLeaveEventHandler(h DirectivesEventHandler) {
	w.directivesEventHandlers.leave = append(w.directivesEventHandlers.leave, h)
}
func (w *Walker) OnDirectivesEnter(ctx *Context, ds *ast.Directives) {
	for _, handler := range w.directivesEventHandlers.enter {
		handler(ctx, ds)
	}
}
func (w *Walker) OnDirectivesLeave(ctx *Context, ds *ast.Directives) {
	for _, handler := range w.directivesEventHandlers.leave {
		handler(ctx, ds)
	}
}
func (w *Walker) walkDirectives(ctx *Context, ds *ast.Directives) {
	w.OnDirectivesEnter(ctx, ds)
	ds.ForEach(func(d ast.Directive, i int) {
		w.walkDirective(ctx, d)
	})
	w.OnDirectivesLeave(ctx, ds)
}
type DocumentEventHandler func(*Context, ast.Document)
type DocumentEventHandlers struct {
	enter []DocumentEventHandler
	leave []DocumentEventHandler
}
func (w *Walker) AddDocumentEnterEventHandler(h DocumentEventHandler) {
	w.documentEventHandlers.enter = append(w.documentEventHandlers.enter, h)
}