All Classes

Class	Description
AbortExecutionException	This Exception indicates that the current execution should be aborted.
AbstractAsyncExecutionStrategy
AbstractDescribedNode<T extends Node>
AbstractNode<T extends Node>
AbstractRule
Anonymizer	Util class which converts schemas and optionally queries into anonymized schemas and queries.
Anonymizer.AnonymizeResult
AntlrHelper
ApolloPersistedQuerySupport	This persisted query support class supports the Apollo scheme where the persisted query id is in ExecutionInput.getExtensions().
AppliedDirectiveArgumentsAreValid
AppliedDirectivesAreValid
Argument
Argument.Builder
ArgumentsOfCorrectType
ArgumentValidationUtil
ArrayValue
ArrayValue.Builder
Assert
AssertException
AstComparator
AstNodeAdapter	Adapts an Ast node to the general node from the util package
AstPrinter	This can take graphql language AST and print it out as a string
AstSignature	This will produce signature and privacy safe query documents that can be used for query categorisation and logging.
AstSorter	A class that helps you sort AST nodes
AstTransformer	Allows for an easy way to "manipulate" the immutable Ast by changing specific nodes and getting back a new Ast containing the changed nodes while everything else is the same.
Async
Async.CombinedBuilder<T>	A builder of materialized objects or CompletableFutures than can present a promise to the list of them
AsyncDataFetcher<T>	A modifier type that indicates the underlying data fetcher is run asynchronously
AsyncExecutionStrategy	The standard graphql execution strategy that runs fields asynchronously non-blocking.
AsyncSerialExecutionStrategy	Async non-blocking execution, but serial: only one field at the time will be resolved.
BlockedFields	This helper class will take a list of regular expressions and match them against the fully qualified name of a type and its fields.
BlockedFields.Builder
BooleanValue
BooleanValue.Builder
Breadcrumb<T>	A specific NodeLocation inside a node.
CapturingReporter	A reporter that captures all the difference events as they occur
ChainedInstrumentation	This allows you to chain together a number of Instrumentation implementations and run them in sequence.
ChainedReporter	A reporter that chains together one or more difference reporters
CodeRegistryVisitor	This ensure that all fields have data fetchers and that unions and interfaces have type resolvers
CoercedVariables	Holds coerced variables, that is their values are now in a canonical form.
Coercing<I,O>	The Coercing interface is used by GraphQLScalarTypes to parse and serialize object values.
CoercingParseLiteralException
CoercingParseLiteralException.Builder
CoercingParseValueException
CoercingParseValueException.Builder
CoercingSerializeException
CoercingSerializeException.Builder
CoercingUtil
CombinedWiringFactory	This combines a number of WiringFactorys together to act as one.
Comment	A single-line comment.
CommentParser	Contains methods for extracting Comment in various positions within and around Nodes
CompletionStageMappingOrderedPublisher<D,U>	A reactive Publisher that bridges over another Publisher of `D` and maps the results to type `U` via a CompletionStage, handling errors in that stage but keeps the results in order of downstream publishing.
CompletionStageMappingPublisher<D,U>	A reactive Publisher that bridges over another Publisher of `D` and maps the results to type `U` via a CompletionStage, handling errors in that stage
CompletionStageOrderedSubscriber<U,D>	This subscriber can be used to map between a Publisher of U elements and map them into CompletionStage of D promises, and it keeps them in the order the Publisher provided them.
CompletionStageSubscriber<U,D>	This subscriber can be used to map between a Publisher of U elements and map them into CompletionStage of D promises.
ConditionalNodeDecision	This callback interface allows custom implementations to decide if a field is included in a query or not.
ConditionalNodeDecisionEnvironment	The parameters given to a ConditionalNodeDecision
ConditionalNodes
Connection<T>	This represents a connection in Relay, which is a list of edges as well as a pageInfo that describes the pagination of that list.
ConnectionCursor	Represents a connection cursor in Relay which is an opaque string that the server understands.
CyclicSchemaAnalyzer	Finds all cycles in a GraphQL Schema.
CyclicSchemaAnalyzer.SchemaCycle
DataFetcher<T>	A data fetcher is responsible for returning a data value back for a given graphql field.
DataFetcherExceptionHandler	This is called when an exception is thrown during DataFetcher.get(DataFetchingEnvironment) execution
DataFetcherExceptionHandlerParameters	The parameters available to DataFetcherExceptionHandlers
DataFetcherExceptionHandlerParameters.Builder
DataFetcherExceptionHandlerResult	The result object for DataFetcherExceptionHandlers
DataFetcherExceptionHandlerResult.Builder
DataFetcherFactories	A helper for DataFetcherFactory
DataFetcherFactory<T>	A DataFetcherFactory allows a level of indirection in providing DataFetchers for graphql fields.
DataFetcherFactoryEnvironment	This is passed to a DataFetcherFactory when it is invoked to get a DataFetcher
DataFetcherFactoryEnvironment.Builder
DataFetcherResult<T>	An object that can be returned from a DataFetcher that contains both data, local context and errors to be added to the final result.
DataFetcherResult.Builder<T>
DataFetchingEnvironment	A DataFetchingEnvironment instance of passed to a DataFetcher as a execution context and its the place where you can find out information to help you resolve a data value given a graphql field input
DataFetchingEnvironmentImpl
DataFetchingEnvironmentImpl.Builder
DataFetchingFieldSelectionSet	This class allows you to retrieve the selection set of fields that have been asked for when the DataFetcher was invoked.
DataFetchingFieldSelectionSetImpl
DataLoaderDispatchStrategy
DefaultConnection<T>	A default implementation of Connection
DefaultConnectionCursor
DefaultEdge<T>
DefaultExtensionsMerger
DefaultGraphqlFieldVisibility	The default field visibility of graphql-java is that everything is visible
DefaultGraphqlTypeComparatorRegistry	Associates a Comparator with a GraphqlTypeComparatorEnvironment to control the scope in which the Comparator can be applied.
DefaultGraphqlTypeComparatorRegistry.Builder
DefaultPageInfo
DefaultTraverserContext<T>
DefaultValuesAreValid
DefaultValueUnboxer	Public API because it should be used as a delegate when implementing a custom ValueUnboxer
DeferDirectiveLabel	Defer and stream directive labels are unique A GraphQL document is only valid if defer and stream directives' label argument is static and unique.
DeferDirectiveOnRootLevel	Defer and stream directives are used on valid root field A GraphQL document is only valid if defer directives are not used on root mutation or subscription types.
DeferDirectiveOnValidOperation	Defer Directive is Used On Valid Operations A GraphQL document is only valid if defer directives are not used on subscription types.
DeferPayload	Represents a defer payload
DeferPayload.Builder
DeferredCallContext	Contains data relevant to the execution of a DeferredFragmentCall.
DeferredExecution	Represents details about the defer execution that can be associated with a MergedField.
DeferredExecutionSupport	The purpose of this class hierarchy is to encapsulate most of the logic for deferring field execution, thus keeping the main execution strategy code clean and focused on the main execution logic.
DeferredExecutionSupport.DeferredExecutionSupportImpl	An implementation that actually executes the deferred fields.
DeferredExecutionSupport.NoOp	A no-op implementation that should be used when incremental support is not enabled for the current execution.
DeferredFragmentCall	Represents a deferred call (aka @defer) to get an execution result sometime after the initial query has returned.
DeferredFragmentCall.FieldWithExecutionResult
Definition<T extends Definition>
DelayedIncrementalPartialResult	Represents a result that is delivered asynchronously, after the initial IncrementalExecutionResult.
DelayedIncrementalPartialResultImpl
DelayedIncrementalPartialResultImpl.Builder
DelegatingDataFetchingEnvironment	DelegatingDataFetchingEnvironment implements DataFetchingEnvironment by delegating to an underlying instance.
DelegatingSubscription	A simple subscription that delegates to another
DeprecatedInputObjectAndArgumentsAreValid
DescribedNode<T extends Node>	Represents a node that can contain a description.
Description
DiffCategory	A classification of difference events.
DifferenceReporter	This is called with each different encountered (including info ones) by a SchemaDiff operation
DiffEvent	This represents the events that the SchemaDiff outputs.
DiffEvent.Builder
DiffImpl	This is an algorithm calculating the optimal edit to change the source graph into the target graph.
DiffImpl.OptimalEdit	An optimal edit from one graph to another.
DiffLevel	This is the level of difference between graphql APIs
DiffSet	Deprecated.
Directive
Directive.Builder
DirectiveDefinition
DirectiveDefinition.Builder
DirectiveIllegalArgumentTypeError
DirectiveIllegalLocationError
DirectiveIllegalReferenceError
DirectiveInfo	Info on all the directives provided by graphql specification
DirectiveLocation
DirectiveLocation.Builder
DirectiveMissingNonNullArgumentError
DirectiveRedefinitionError
Directives	The directives that are understood by graphql-java
DirectivesContainer<T extends DirectivesContainer>	Represents a language node that can contain Directives.
DirectivesResolver	This turns AST directives into runtime directives with resolved types and so on
DirectivesUtil
DirectivesUtil.DirectivesHolder	A holder class that breaks a list of directives into maps to be more easily accessible in using classes
DirectiveUndeclaredError
DirectiveUnknownArgumentError
Document
Document.Builder
DocumentAndVariables
DocumentAndVariables.Builder
DocumentVisitor
EchoingWiringFactory	A wiring factory that will echo back the objects defined.
Edge<T>	Represents an edge in Relay which is essentially a node of data T and the cursor for that node.
Edge
EditOperation	An edit operation between two graphs can be one of six types: insert vertex, delete vertex, change vertex, insert edge, delete edge, change edge
EditOperation.Operation
EditOperationAnalysisResult
EditOperationAnalyzer	Higher level GraphQL semantic assigned to
EditorialCostForMapping
EmptyDataLoaderRegistryInstance
ENFMerger
EnumTypeDefinition
EnumTypeDefinition.Builder
EnumTypeExtensionDefinition
EnumTypeExtensionDefinition.Builder
EnumValue
EnumValue.Builder
EnumValueDefinition
EnumValueDefinition.Builder
EnumValuesProvider	Provides the Java runtime value for each graphql Enum value.
ErrorClassification	Errors in graphql-java can have a classification to help with the processing of errors.
ErrorType	All the errors in graphql belong to one of these categories
EscapeUtil
ExceptionWhileDataFetching	This graphql error will be used if a runtime exception is encountered while a data fetcher is invoked
ExecutableDefinitions
ExecutableNormalizedField	An ExecutableNormalizedField represents a field in an executable graphql operation.
ExecutableNormalizedField.Builder
ExecutableNormalizedOperation	A ExecutableNormalizedOperation represent how the text of a graphql operation (sometimes known colloquially as a query) will be executed at runtime according to the graphql specification.
ExecutableNormalizedOperationFactory	This factory can create a ExecutableNormalizedOperation which represents what would be executed during a given graphql operation.
ExecutableNormalizedOperationFactory.Options
ExecutableNormalizedOperationToAstCompiler	This class can take a list of ExecutableNormalizedFields and compiling out a normalised operation Document that would represent how those fields may be executed.
ExecutableNormalizedOperationToAstCompiler.CompilerResult	The result is a Document and a map of variables that would go with that document.
ExecuteObjectInstrumentationContext
Execution
ExecutionContext
ExecutionContextBuilder
ExecutionId	This opaque identifier is used to identify a unique query execution
ExecutionIdProvider	A provider of ExecutionIds
ExecutionInput	This represents the series of values that can be input on a graphql query execution
ExecutionInput.Builder
ExecutionResult	This simple value class represents the result of performing a graphql query.
ExecutionResult.Builder<B extends ExecutionResult.Builder<B>>
ExecutionResultImpl
ExecutionResultImpl.Builder<T extends ExecutionResultImpl.Builder<T>>
ExecutionStepInfo	As the graphql query executes, it forms a hierarchy from parent fields (and their type) to their child fields (and their type) until a scalar type is encountered; this class captures that execution type information.
ExecutionStepInfo.Builder
ExecutionStepInfoFactory
ExecutionStrategy	An execution strategy is give a list of fields from the graphql query to execute and find values for using a recursive strategy.
ExecutionStrategyInstrumentationContext
ExecutionStrategyParameters	The parameters that are passed to execution strategies
ExecutionStrategyParameters.Builder
ExecutionTrackingResult	This is the result of the agent tracking an execution.
ExecutionTrackingResult.BatchLoadingCall
ExecutionTrackingResult.DFResultType
ExecutorInstrumentation	This instrumentation can be used to control on what thread calls to DataFetchers happen on.
ExecutorInstrumentation.Builder
ExperimentalApi	This represents code that the graphql-java project considers experimental API and while our intention is that it will progress to be PublicApi, its existence, signature or behavior may change between releases.
ExtendedBailStrategy
ExtensionsBuilder	This class can be used to help build the graphql `extensions` map.
ExtensionsMerger	This interface is a callback asking code to merge two maps with an eye to creating the graphql `extensions` value.
FallbackDataLoaderDispatchStrategy	Used when the execution strategy is not an AsyncExecutionStrategy: simply dispatch always after each DF.
FetchedValue	Note: This is returned by InstrumentationFieldCompleteParameters.getFetchedValue() and therefore part of the public despite never used in a method signature.
Field
Field.Builder
FieldAndArguments	This represents a field and its arguments that may be validated.
FieldCollector	A field collector can iterate over field selection sets and build out the sub fields that have been selected, expanding named and inline fragments as it goes.
FieldCollectorParameters	Internal because FieldCollector is internal.
FieldCollectorParameters.Builder
FieldComplexityCalculator	Used to calculate the complexity of a field.
FieldComplexityEnvironment
FieldCoordinates	A field in graphql is uniquely located within a parent type and hence code elements like DataFetcher need to be specified using those coordinates.
FieldDefinition
FieldDefinition.Builder
FieldFetchingInstrumentationContext	FieldFetchingInstrumentationContext is returned back from the Instrumentation.beginFieldFetching(InstrumentationFieldFetchParameters, InstrumentationState) method, and it's much like the normal InstrumentationContext type except it also gives the value that was returned by a fields DataFetcher.
FieldsOnCorrectType
FieldValidation	This pluggable interface allows you to validate the fields and their argument inputs before query execution.
FieldValidationEnvironment	This contains all of the field and their arguments for a given query.
FieldValidationInstrumentation	This Instrumentation allows you to validate the fields of the query before the query is executed.
FieldValueInfo	The FieldValueInfo holds the type of field that was fetched and completed along with the completed value.
FieldValueInfo.CompleteValueType
FieldVisibilitySchemaTransformation	Transforms a schema by applying a visibility predicate to every field.
FieldWiringEnvironment
FloatValue
FloatValue.Builder
FpKit
FragmentDefinition	Provided to the DataFetcher, therefore public API
FragmentDefinition.Builder
FragmentsOnCompositeType
FragmentSpread
FragmentSpread.Builder
GoodFaithIntrospection	This Instrumentation ensure that a submitted introspection query is done in good faith.
GoodFaithIntrospection.BadFaithIntrospectionError
GraphQL	This class is where all graphql-java query execution begins.
GraphQL.Builder
GraphqlAntlrToLanguage
GraphQLAppliedDirective	An applied directive represents the instance of a directive that is applied to a schema element, as opposed to it definition
GraphQLAppliedDirective.Builder
GraphQLAppliedDirectiveArgument	This represents the argument values that can be placed on an GraphQLAppliedDirective.
GraphQLAppliedDirectiveArgument.Builder
GraphQLArgument	This defines an argument that can be supplied to a graphql field (via GraphQLFieldDefinition.
GraphQLArgument.Builder
GraphqlBooleanCoercing	The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
GraphQLCodeRegistry	The GraphQLCodeRegistry holds that execution code that is associated with graphql types, namely the DataFetchers associated with fields, the TypeResolvers associated with abstract types and the GraphqlFieldVisibility
GraphQLCodeRegistry.Builder
GraphQLCompositeType
GraphQLContext	This context object can be used to contain key values that can be useful as "context" when executing DataFetchers
GraphQLContext.Builder
GraphQLDirective	A directive can be used to modify the behavior of a graphql field or type.
GraphQLDirective.Builder
GraphQLDirectiveContainer	Represents a graphql runtime type that can have GraphQLAppliedDirectives.
GraphqlDirectivesContainerTypeBuilder<B extends GraphqlDirectivesContainerTypeBuilder<B,BASE>,BASE extends GraphqlTypeBuilder<BASE>>
GraphqlElementParentTree	This represents a hierarchy an graphql runtime element upwards to its associated parent elements.
GraphQLEnumType	A graphql enumeration type has a limited set of values.
GraphQLEnumType.Builder
GraphQLEnumValueDefinition	A graphql enumeration type has a limited set of values and this defines one of those unique values
GraphQLEnumValueDefinition.Builder
GraphQLError	The interface describing graphql errors NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
GraphQLError.Builder<B extends GraphQLError.Builder<B>>	A builder of GraphQLErrors
GraphqlErrorBuilder<B extends GraphqlErrorBuilder<B>>	This helps you build GraphQLErrors and also has a quick way to make a DataFetcherResults from that error.
GraphqlErrorException	A base class for graphql runtime exceptions that also implement GraphQLError and can be used in a general sense direct or have specialisations made of it.
GraphqlErrorException.Builder
GraphqlErrorException.BuilderBase<T extends GraphqlErrorException.BuilderBase<T,B>,B extends GraphqlErrorException>	A trait like base class that contains the properties that GraphqlErrorException handles and can be used by other classes to derive their own builders.
GraphqlErrorHelper	This little helper allows GraphQlErrors to implement common things (hashcode/ equals ) and to specification more easily
GraphQLException
GraphQLFieldDefinition	Fields are the ways you get data values in graphql and a field definition represents a field, its type, the arguments it takes and the DataFetcher used to get data values for that field.
GraphQLFieldDefinition.Builder
GraphQLFieldsContainer	Types that can contain output fields are marked with this interface
GraphqlFieldVisibility	This allows you to control the visibility of graphql fields.
GraphqlFloatCoercing	The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
GraphqlIDCoercing	The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
GraphQLImplementingType	A GraphQLType which can implement interfaces
GraphQLInputFieldsContainer	Types that can contain input fields are marked with this interface
GraphQLInputObjectField	Input objects defined via GraphQLInputObjectType contains these input fields.
GraphQLInputObjectField.Builder
GraphQLInputObjectType	graphql clearly delineates between the types of objects that represent the output of a query and input objects that can be fed into a graphql mutation.
GraphQLInputObjectType.Builder
GraphQLInputSchemaElement	A schema element that is concerned with input.
GraphQLInputType	Input types represent those set of types that are allowed to be accepted as graphql mutation input, as opposed to GraphQLOutputTypes which can only be used as graphql response output.
GraphQLInputValueDefinition	Named schema elements that contain input type information.
GraphqlIntCoercing	The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
GraphQLInterfaceType	In graphql, an interface is an abstract type that defines the set of fields that a type must include to implement that interface.
GraphQLInterfaceType.Builder
GraphQLList	A modified type that indicates there is a list of the underlying wrapped type, eg a list of strings or a list of booleans.
GraphQLModifiedType	A modified type wraps another graphql type and modifies it behavior
GraphQLNamedInputType	Input types represent those set of types that are allowed to be accepted as graphql mutation input, as opposed to GraphQLOutputTypes which can only be used as graphql response output.
GraphQLNamedOutputType	Output types represent those set of types that are allowed to be sent back as a graphql response, as opposed to GraphQLInputTypes which can only be used as graphql mutation input.
GraphQLNamedSchemaElement	A Schema element which has a name and also a description and AST Node which it is based on.
GraphQLNamedType	A GraphQLType which is also a named element, which means it has a getName() method.
GraphQLNonNull	A modified type that indicates there the underlying wrapped type will not be null.
GraphQLNullableType
GraphQLObjectType	This is the work horse type and represents an object with one or more field values that can be retrieved by the graphql system.
GraphQLObjectType.Builder
GraphQLOutputType	Output types represent those set of types that are allowed to be sent back as a graphql response, as opposed to GraphQLInputTypes which can only be used as graphql mutation input.
GraphQLScalarType	A scalar type is a leaf node in the graphql tree of types.
GraphQLScalarType.Builder
GraphQLSchema	The schema represents the combined type system of the graphql engine.
GraphQLSchema.Builder
GraphQLSchema.BuilderWithoutTypes
GraphQLSchemaElement	A GraphQLSchema can be viewed as a graph of GraphQLSchemaElement.
GraphQLSchemaElementAdapter
GraphQLSchemaTraversalControl	This indicates what traversal control to apply during the visitation and can be created via calls to methods like ok() or changeNode(GraphQLSchemaElement) say
GraphQLSchemaVisitor	This visitor interface offers more "smarts" above GraphQLTypeVisitor and aims to be easier to use with more type safe helpers.
GraphQLSchemaVisitor.AppliedDirectiveArgumentVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLAppliedDirectiveArgument
GraphQLSchemaVisitor.AppliedDirectiveVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLAppliedDirective
GraphQLSchemaVisitor.ArgumentVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLArgument
GraphQLSchemaVisitor.DirectiveVisitorEnvironment
GraphQLSchemaVisitor.EnumTypeVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLEnumType
GraphQLSchemaVisitor.EnumValueDefinitionVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLEnumValueDefinition
GraphQLSchemaVisitor.FieldDefinitionVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLFieldDefinition
GraphQLSchemaVisitor.InputObjectFieldVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLInputObjectField
GraphQLSchemaVisitor.InputObjectTypeVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLInputObjectType
GraphQLSchemaVisitor.InterfaceTypeVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLInterfaceType
GraphQLSchemaVisitor.ObjectVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLObjectType
GraphQLSchemaVisitor.ScalarTypeVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLScalarType
GraphQLSchemaVisitor.SchemaElementVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLSchemaElement
GraphQLSchemaVisitor.UnionTypeVisitorEnvironment	A GraphQLSchemaVisitorEnvironment environment specific to GraphQLUnionType
GraphQLSchemaVisitorEnvironment<T extends GraphQLSchemaElement>
GraphqlStringCoercing	The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
GraphQLType	A type inside the GraphQLSchema.
GraphqlTypeBuilder<B extends GraphqlTypeBuilder<B>>
GraphQLTypeCollectingVisitor
GraphqlTypeComparatorEnvironment	Defines the scope to control where the registered Comparator can be applied.
GraphqlTypeComparatorEnvironment.Builder
GraphqlTypeComparatorRegistry
GraphqlTypeComparators
GraphQLTypeReference	A special type to allow a object/interface types to reference itself.
GraphQLTypeResolvingVisitor
GraphQLTypeUtil	A utility class that helps work with GraphQLTypes
GraphQLTypeVisitor	GraphQLTypeVisitor can be used to visit all the elements of a schema (types, fields, directives and so on) in a visitor pattern.
GraphQLTypeVisitorStub	Base implementation of GraphQLTypeVisitor for convenience.
GraphQLUnionType	A union type is a polymorphic type that dynamically represents one of more concrete object types.
GraphQLUnionType.Builder
GraphQLUnmodifiedType
HungarianAlgorithm	An implementation of the Hungarian algorithm for solving the assignment problem.
I18n
I18n.BundleType	This enum is a type safe way to control what resource bundle to load from
I18nMsg	A class that represents the intention to create a I18n message
IdGenerator	An id generator that uses SecureRandom for the initial seed and Random thereafter.
IgnoredChar	Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
IgnoredChar.IgnoredCharKind
IgnoredChars	Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
IllegalNameError
ImmutableKit
ImmutableMapWithNullValues<K,V>	The standard ImmutableMap does not allow null values.
ImplementingTypeDefinition<T extends TypeDefinition>	A TypeDefinition that might implement interfaces
IncrementalCall<T extends IncrementalPayload>	Represents an incremental call (resulted from the usage of @defer or @stream).
IncrementalCallState	This provides support for @defer directives on fields that mean that results will be sent AFTER the main result is sent via a Publisher stream.
IncrementalExecutionResult	A result that is part of an execution that includes incrementally delivered data (data has been deferred of streamed).
IncrementalExecutionResultImpl
IncrementalExecutionResultImpl.Builder
IncrementalPayload	Represents a payload that can be resolved after the initial response.
IncrementalPayload.Builder<T extends IncrementalPayload.Builder<T>>
IncrementalUtils
InlineFragment
InlineFragment.Builder
InMemoryPersistedQueryCache	A PersistedQueryCache that is just an in memory map of known queries.
InMemoryPersistedQueryCache.Builder
InputAndOutputTypesUsedAppropriately	Schema validation rule ensuring no input type forms an unbroken non-nullable recursion, as such a type would be impossible to satisfy
InputInterceptor	This INTERNAL class can be used to intercept input values before they are coerced into runtime values by the ValuesResolver code.
InputMapDefinesTooManyFieldsException	https://facebook.github.io/graphql/#sec-Input-Objects - This unordered map should not contain any entries with names not defined by a field of this input object type, otherwise an error should be thrown.
InputObjectTypeDefinition
InputObjectTypeDefinition.Builder
InputObjectTypeExtensionDefinition
InputObjectTypeExtensionDefinition.Builder
InputValueDefinition
InputValueDefinition.Builder
InputValueWithState	Used by @GraphQLArgument and GraphQLInputObjectField to represent different value states.
Instrumentation	Provides the capability to instrument the execution steps of a GraphQL query.
InstrumentationContext<T>	When a Instrumentation.'beginXXX()' method is called then it must return a non null InstrumentationContext that will be invoked when the step is first dispatched and then when it completes.
InstrumentationCreateStateParameters	Parameters sent to Instrumentation methods
InstrumentationExecuteOperationParameters	Parameters sent to Instrumentation methods
InstrumentationExecutionParameters	Parameters sent to Instrumentation methods
InstrumentationExecutionStrategyParameters	Parameters sent to Instrumentation methods
InstrumentationFieldCompleteParameters	Parameters sent to Instrumentation methods
InstrumentationFieldFetchParameters	Parameters sent to Instrumentation methods
InstrumentationFieldParameters	Parameters sent to Instrumentation methods
InstrumentationState	An Instrumentation implementation can create this as a stateful object that is then passed to each instrumentation method, allowing state to be passed down with the request execution
InstrumentationValidationParameters	Parameters sent to Instrumentation methods
InterfaceFieldArgumentNotOptionalError
InterfaceFieldArgumentRedefinitionError
InterfaceFieldRedefinitionError
InterfaceImplementedMoreThanOnceError
InterfaceImplementingItselfError
InterfaceTypeDefinition
InterfaceTypeDefinition.Builder
InterfaceTypeExtensionDefinition
InterfaceTypeExtensionDefinition.Builder
InterfaceWiringEnvironment
InterfaceWithCircularImplementationHierarchyError
Internal	This represents code that the graphql-java project considers internal code that MAY not be stable within major releases.
Interning	Interner allowing object-identity comparison of key entities like field names.
InterThreadMemoizedSupplier<T>	This memoizing supplier DOES use locked double locking to set its value.
Introspection	GraphQl has a unique capability called Introspection that allow consumers to inspect the system and discover the fields and types available and makes the system self documented.
Introspection.DirectiveLocation
Introspection.TypeKind
IntrospectionDataFetcher<T>	Special DataFetcher which is only used inside Introspection
IntrospectionDataFetchingEnvironment	Extracted from DataFetchingEnvironment to only capture the data really needed for Introspection
IntrospectionDisabledError
IntrospectionQuery
IntrospectionQueryBuilder	IntrospectionQueryBuilder allows you to build introspection queries controlled by the options you specify
IntrospectionQueryBuilder.Options
IntrospectionResultToSchema
IntrospectionWithDirectivesSupport	The graphql specification does not allow you to retrieve the directives and their argument values that are present on types, enums, fields and input fields, so this class allows you to change the schema and enhance the Introspection types to contain this information.
IntrospectionWithDirectivesSupport.DirectivePredicate	A callback which allows you to decide what directives may be included in introspection extensions
IntrospectionWithDirectivesSupport.DirectivePredicateEnvironment	The parameter environment on a call to IntrospectionWithDirectivesSupport.DirectivePredicate
IntValue
IntValue.Builder
InvalidCursorException
InvalidPageSizeException
InvalidSchemaException
InvalidSyntaxError
InvalidSyntaxException	This exception is thrown by the Parser if the graphql syntax is not valid
InvalidUnicodeSyntaxException
KnownArgumentNames
KnownDirectives
KnownFragmentNames
KnownTypeNames
LambdaFetchingSupport
LanguageTraversal
LegacyCoercingInputInterceptor
LevelMap	This data structure tracks the number of expected calls on a given level
LightDataFetcher<T>	A LightDataFetcher is a specialised version of DataFetcher that is passed more lightweight arguments when it is asked to fetch values.
ListType
ListType.Builder
LockKit	This provides reentrant locking support for our code base.
LockKit.ComputedOnce	Will allow for lazy computation of some values just once
LockKit.ReentrantLock	A class to run code inside a reentrant lock
LoneAnonymousOperation
MapEnumValuesProvider
Mapping	A mapping (in the math sense) from a list of vertices to another list of vertices.
MaxQueryComplexityInstrumentation	Prevents execution if the query complexity is greater than the specified maxComplexity.
MaxQueryDepthInstrumentation	Prevents execution if the query depth is greater than the specified maxDepth.
MergedField	This represents all Fields in a query which overlap and are merged into one.
MergedField.Builder
MergedSelectionSet
MergedSelectionSet.Builder
MissingInterfaceFieldArgumentsError
MissingInterfaceFieldError
MissingInterfaceTypeError
MissingRootTypeException	This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
MissingScalarImplementationError
MissingTransitiveInterfaceError
MissingTypeError
MissingTypeResolverError
MockedWiringFactory
MoreTokensSyntaxException
MultiReadOnlyGraphQLTypeVisitor	A delegating type visitor that allows you to call N visitors in a list and always continues via TraversalControl.CONTINUE
MultiSourceReader	This reader allows you to read N number readers and combine them as one logical reader however you can then map back to the underlying readers in terms of their source name and the relative lines numbers.
MultiSourceReader.Builder
MultiSourceReader.SourceAndLine
Mutable	This marks a type as mutable which means after constructing it can be changed.
MutableRef<T>	This class is useful for creating a mutable reference to a variable that can be changed when you are in an effectively final bit of code.
NamedNode<T extends NamedNode>	Represents a language node that has a name
NaturalEnumValuesProvider<T extends java.lang.Enum<T>>	Simple EnumValuesProvided which maps the GraphQL Enum name to the Java Enum instance.
NoContextChainedInstrumentation	This version of ChainedInstrumentation will call a list of Instrumentations but it will never back on the returned InstrumentationContext objects, hence it is only suitable to certain use cases.
Node<T extends Node>	The base interface for virtually all graphql language elements NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
NodeAdapter<T>	Adapts an arbitrary class to behave as a node.
NodeBuilder
NodeChildrenContainer	Container of children of a Node.
NodeChildrenContainer.Builder
NodeDirectivesBuilder
NodeLocation	General position of a Node inside a parent.
NodeMultiZipper<T>
NodeParentTree<T extends Node>	This represents a hierarchy from a graphql language node upwards to its associated parent nodes.
NodeToRuleCapturingParser	A parser that will capture parsing context data which can be later used for accessing tokens that are discarded during the conventional parsing process (like comments).
NodeToRuleCapturingParser.ParserContext
NodeTraverser	Lets you traverse a Node tree.
NodeUtil	Helper class for working with Nodes
NodeUtil.GetOperationResult
NodeVisitor	Used by NodeTraverser to visit Node.
NodeVisitorStub	Convenient implementation of NodeVisitor for easy subclassing methods handling different types of Nodes in one method.
NodeVisitorWithTypeTracking	Internally used node visitor which delegates to a QueryVisitor with type information about the visited field.
NodeZipper<T>
NodeZipper.ModificationType
NoFragmentCycles
NoIntrospectionGraphqlFieldVisibility	Deprecated. This is no longer the best way to prevent Introspection - Introspection.enabledJvmWide(boolean) can be used instead
NonNullableFieldValidator	This will check that a value is non-null when the type definition says it must be and, it will throw NonNullableFieldWasNullException if this is not the case.
NonNullableFieldWasNullError	This is the base error that indicates that a non null field value was in fact null.
NonNullableFieldWasNullException	See (https://spec.graphql.org/October2021/#sec-Errors-and-Non-Nullability), but if a non nullable field actually resolves to a null value and the parent type is nullable then the parent must in fact become null so we use exceptions to indicate this special case
NonNullableValueCoercedAsNullException	This is thrown if a non nullable value is coerced to a null value
NonNullType
NonNullType.Builder
NonSDLDefinitionError
NonUniqueArgumentError
NonUniqueDirectiveError
NonUniqueNameError
NoOpPreparsedDocumentProvider
NoopWiringFactory
NormalizedDeferredExecution	Represents details about the defer execution that can be associated with a ExecutableNormalizedField.
NormalizedInputValue	An argument value with type information.
NotAnInputTypeError
NotAnOutputTypeError
NoUnbrokenInputCycles	Schema validation rule ensuring no input type forms an unbroken non-nullable recursion, as such a type would be impossible to satisfy
NoUndefinedVariables
NoUnusedFragments
NoUnusedVariables
NullValue
NullValue.Builder
ObjectField
ObjectField.Builder
ObjectTypeDefinition
ObjectTypeDefinition.Builder
ObjectTypeExtensionDefinition
ObjectTypeExtensionDefinition.Builder
ObjectValue
ObjectValue.Builder
OneOfInputObjectRules
OneOfNullValueException	The input map to One Of Input Types MUST only have 1 entry with a non null value
OneOfTooManyKeysException	The input map to One Of Input Types MUST only have 1 entry
OperationDefinition
OperationDefinition.Builder
OperationDefinition.Operation
OperationRedefinitionError
OperationTypeDefinition
OperationTypeDefinition.Builder
OperationTypesMustBeObjects
OverlappingFieldsCanBeMerged
PageInfo	Represents pagination information in Relay about edges when used inside a connection See https://facebook.github.io/relay/graphql/connections.htm#sec-undefined.PageInfo
Pair<T,U>
ParseAndValidate	This class allows you to parse and validate a graphql query without executing it.
ParseAndValidateResult	A result object used in ParseAndValidate helper that indicates the outcomes of a parse and validate operation.
ParseAndValidateResult.Builder
ParseCancelledException
ParseCancelledTooDeepException
ParseCancelledTooManyCharsException
Parser	This can parse graphql syntax, both Query syntax and Schema Definition Language (SDL) syntax, into an Abstract Syntax Tree (AST) represented by a Document
ParserEnvironment	This is the arguments that can be passed to a Parser
ParserEnvironment.Builder
ParserOptions	Options that control how the Parser behaves.
ParserOptions.Builder
ParsingListener	This listener interface is invoked for each token parsed by the graphql parser code.
ParsingListener.Token	This represents a token that has been parsed
PerLevelDataLoaderDispatchStrategy
PersistedQueryCache	This interface is used to abstract an actual cache that can cache parsed persistent queries.
PersistedQueryCacheMiss	The call back when a valid persisted query is not in cache and it needs to be compiled and validated by the graphql engine.
PersistedQueryError
PersistedQueryIdInvalid
PersistedQueryNotFound	An exception that indicates the query id is not valid and can be found ever in cache
PersistedQuerySupport	This abstract class forms the basis for persistent query support.
PossibleFragmentSpreads
PossibleMappingsCalculator	We don't want to allow arbitrary schema changes.
PossibleMappingsCalculator.VertexContextSegment
PreparsedDocumentEntry	An instance of a preparsed document entry represents the result of a query parse and validation.
PreparsedDocumentProvider	Interface that allows clients to hook in Document caching and/or the whitelisting of queries.
PrettyAstPrinter	A printer that acts as a code formatter.
PrettyAstPrinter.PrettyPrinterOptions	Contains options that modify how a document is printed.
PrettyAstPrinter.PrettyPrinterOptions.Builder
PrettyAstPrinter.PrettyPrinterOptions.IndentType
PrintStreamReporter	A reporter that prints its output to a PrintStream
PropertyDataFetcher<T>	This is the default data fetcher used in graphql-java, and it will examine maps, records and POJO java beans for values that match the desired name, typically the field name, or it will use a provided function to obtain values.
PropertyDataFetcherHelper	This class is the guts of a property data fetcher and also used in AST code to turn in memory java objects into AST elements
PropertyFetchingImpl	A re-usable class that can fetch from POJOs
ProvidedNonNullArguments
PublicApi	This represents code that the graphql-java project considers public API and has an imperative to be stable within major releases.
PublicSpi	This represents code that the graphql-java project considers public SPI and has an imperative to be stable within major releases.
QueryAppliedDirective	An applied directive represents the instance of a directive that is applied to a query element such as a field or fragment.
QueryAppliedDirective.Builder
QueryAppliedDirectiveArgument	This represents the argument values that can be placed on an QueryAppliedDirective.
QueryAppliedDirectiveArgument.Builder
QueryComplexityCalculator	This can calculate the complexity of an operation using the specified FieldComplexityCalculator you pass into it.
QueryComplexityCalculator.Builder
QueryComplexityInfo	The query complexity info.
QueryComplexityInfo.Builder
QueryDepthInfo	The query depth info.
QueryDepthInfo.Builder
QueryDirectives	This gives you access to the immediate directives on a MergedField.
QueryDirectives.Builder
QueryDirectivesBuilder
QueryDirectivesImpl	These objects are ALWAYS in the context of a single MergedField
QueryOperationMissingError
QueryReducer<T>	Used by QueryTraverser to reduce the fields of a Document (or part of it) to a single value.
QueryTransformer	Helps to transform a Document (or parts of it) and tracks at the same time the corresponding Schema types.
QueryTransformer.Builder
QueryTraversalOptions	This options object controls how QueryTraverser works
QueryTraverser	Helps to traverse (or reduce) a Document (or parts of it) and tracks at the same time the corresponding Schema types.
QueryTraverser.Builder
QueryVisitor	Used by QueryTraverser to visit the nodes of a Query.
QueryVisitorFieldArgumentEnvironment
QueryVisitorFieldArgumentEnvironmentImpl
QueryVisitorFieldArgumentInputValue	This describes the tree structure that forms from a argument input type, especially with `input ComplexType { ....}` types that might in turn contain other complex types and hence form a tree of values.
QueryVisitorFieldArgumentInputValueImpl
QueryVisitorFieldArgumentValueEnvironment
QueryVisitorFieldArgumentValueEnvironmentImpl
QueryVisitorFieldEnvironment
QueryVisitorFieldEnvironmentImpl
QueryVisitorFragmentDefinitionEnvironment
QueryVisitorFragmentDefinitionEnvironmentImpl
QueryVisitorFragmentSpreadEnvironment
QueryVisitorFragmentSpreadEnvironmentImpl
QueryVisitorInlineFragmentEnvironment
QueryVisitorInlineFragmentEnvironmentImpl
QueryVisitorStub
RawVariables	Holds raw variables, which have not been coerced yet into CoercedVariables
Relay	This can be used to compose graphql runtime types that implement that Relay specification.
Relay.ResolvedGlobalId
ReplaceNode	Special class to be set as var in TraverserContext.setVar(Class, Object) to indicate that the current node should be replaced.
ResolveType
ResultNodesInfo	This class is used to track the number of result nodes that have been created during execution.
ResultPath	As a graphql query is executed, each field forms a hierarchical path from parent field to child field and this class represents that path as a series of segments.
RulesVisitor
RuntimeWiring	A runtime wiring is a specification of data fetchers, type resolvers and custom scalars that are needed to wire together a functional GraphQLSchema
RuntimeWiring.Builder
SafeTokenReader	This reader will only emit a maximum number of characters from it.
SafeTokenSource	This token source can wrap a lexer and if it asks for more than a maximum number of tokens the user can take some action, typically throw an exception to stop lexing.
ScalarInfo	Info on all the standard scalar objects provided by graphql-java
ScalarLeaves
Scalars	This contains the implementations of the Scalar types that ship with graphql-java.
ScalarTypeDefinition
ScalarTypeDefinition.Builder
ScalarTypeExtensionDefinition
ScalarTypeExtensionDefinition.Builder
ScalarValue<T extends Value>
ScalarWiringEnvironment
SchemaDefinition
SchemaDefinition.Builder
SchemaDiff	The SchemaDiff is called with a DiffSet and will report the differences in the graphql schema APIs by raising events to a DifferenceReporter
SchemaDiff.Options	Options for controlling the diffing process
SchemaDifference	Any kind of difference between two schemas is a SchemaDifference.
SchemaDifference.AppliedDirectiveAddition
SchemaDifference.AppliedDirectiveArgumentAddition
SchemaDifference.AppliedDirectiveArgumentDeletion
SchemaDifference.AppliedDirectiveArgumentRename
SchemaDifference.AppliedDirectiveArgumentValueModification
SchemaDifference.AppliedDirectiveDeletion
SchemaDifference.AppliedDirectiveDifference
SchemaDifference.AppliedDirectiveDirectiveArgumentLocation
SchemaDifference.AppliedDirectiveEnumLocation
SchemaDifference.AppliedDirectiveEnumValueLocation
SchemaDifference.AppliedDirectiveInputObjectFieldLocation
SchemaDifference.AppliedDirectiveInputObjectLocation
SchemaDifference.AppliedDirectiveInterfaceFieldArgumentLocation
SchemaDifference.AppliedDirectiveInterfaceFieldLocation
SchemaDifference.AppliedDirectiveInterfaceLocation
SchemaDifference.AppliedDirectiveLocationDetail	SCHEMA, SCALAR, OBJECT, FIELD_DEFINITION, ARGUMENT_DEFINITION, INTERFACE, UNION, ENUM, ENUM_VALUE, INPUT_OBJECT, INPUT_FIELD_DEFINITION
SchemaDifference.AppliedDirectiveObjectFieldArgumentLocation
SchemaDifference.AppliedDirectiveObjectFieldLocation
SchemaDifference.AppliedDirectiveObjectLocation
SchemaDifference.AppliedDirectiveRenamed
SchemaDifference.AppliedDirectiveScalarLocation
SchemaDifference.AppliedDirectiveSchemaLocation
SchemaDifference.AppliedDirectiveUnionLocation
SchemaDifference.DirectiveAddition
SchemaDifference.DirectiveArgumentAddition
SchemaDifference.DirectiveArgumentDefaultValueModification
SchemaDifference.DirectiveArgumentDeletion
SchemaDifference.DirectiveArgumentRename
SchemaDifference.DirectiveArgumentTypeModification
SchemaDifference.DirectiveDeletion
SchemaDifference.DirectiveDifference
SchemaDifference.DirectiveModification
SchemaDifference.DirectiveModificationDetail
SchemaDifference.EnumAddition
SchemaDifference.EnumDeletion
SchemaDifference.EnumDifference
SchemaDifference.EnumModification
SchemaDifference.EnumModificationDetail
SchemaDifference.EnumValueAddition
SchemaDifference.EnumValueDeletion
SchemaDifference.EnumValueRenamed
SchemaDifference.InputObjectAddition
SchemaDifference.InputObjectDeletion
SchemaDifference.InputObjectDifference
SchemaDifference.InputObjectFieldAddition
SchemaDifference.InputObjectFieldDefaultValueModification
SchemaDifference.InputObjectFieldDeletion
SchemaDifference.InputObjectFieldRename
SchemaDifference.InputObjectFieldTypeModification
SchemaDifference.InputObjectModification
SchemaDifference.InputObjectModificationDetail
SchemaDifference.InterfaceAddition
SchemaDifference.InterfaceDeletion
SchemaDifference.InterfaceDifference
SchemaDifference.InterfaceFieldAddition
SchemaDifference.InterfaceFieldArgumentAddition
SchemaDifference.InterfaceFieldArgumentDefaultValueModification
SchemaDifference.InterfaceFieldArgumentDeletion
SchemaDifference.InterfaceFieldArgumentRename
SchemaDifference.InterfaceFieldArgumentTypeModification
SchemaDifference.InterfaceFieldDeletion
SchemaDifference.InterfaceFieldRename
SchemaDifference.InterfaceFieldTypeModification
SchemaDifference.InterfaceInterfaceImplementationAddition
SchemaDifference.InterfaceInterfaceImplementationDeletion
SchemaDifference.InterfaceModification
SchemaDifference.InterfaceModificationDetail
SchemaDifference.ObjectAddition
SchemaDifference.ObjectDeletion
SchemaDifference.ObjectDifference
SchemaDifference.ObjectFieldAddition
SchemaDifference.ObjectFieldArgumentAddition
SchemaDifference.ObjectFieldArgumentDefaultValueModification
SchemaDifference.ObjectFieldArgumentDeletion
SchemaDifference.ObjectFieldArgumentRename
SchemaDifference.ObjectFieldArgumentTypeModification
SchemaDifference.ObjectFieldDeletion
SchemaDifference.ObjectFieldRename
SchemaDifference.ObjectFieldTypeModification
SchemaDifference.ObjectInterfaceImplementationAddition
SchemaDifference.ObjectInterfaceImplementationDeletion
SchemaDifference.ObjectModification
SchemaDifference.ObjectModificationDetail
SchemaDifference.ScalarAddition
SchemaDifference.ScalarDeletion
SchemaDifference.ScalarDifference
SchemaDifference.ScalarModification
SchemaDifference.ScalarModificationDetail
SchemaDifference.SchemaAddition
SchemaDifference.SchemaDeletion
SchemaDifference.SchemaModification
SchemaDifference.SchemaModificationDetail
SchemaDifference.UnionAddition
SchemaDifference.UnionDeletion
SchemaDifference.UnionDifference
SchemaDifference.UnionMemberAddition
SchemaDifference.UnionMemberDeletion
SchemaDifference.UnionModification
SchemaDifference.UnionModificationDetail
SchemaDiffing
SchemaDiffingCancelledException
SchemaDiffSet	Interface used to define 2 schemas that can be diffed by the SchemaDiff operation.
SchemaDirectiveWiring	A SchemaDirectiveWiring is responsible for enhancing a runtime element based on directives placed on that element in the Schema Definition Language (SDL).
SchemaDirectiveWiringEnvironment<T extends GraphQLDirectiveContainer>	SchemaDirectiveWiring is passed this object as parameters when it builds out behaviour
SchemaDirectiveWiringEnvironmentImpl<T extends GraphQLDirectiveContainer>
SchemaElementChildrenContainer
SchemaElementChildrenContainer.Builder
SchemaExtensionDefinition
SchemaExtensionDefinition.Builder
SchemaExtensionsChecker
SchemaGenerator	This can generate a working runtime schema from a type registry and runtime wiring
SchemaGenerator.Options	These options control how the schema generation works
SchemaGeneratorDirectiveHelper	This contains the helper code that allows SchemaDirectiveWiring implementations to be invoked during schema generation.
SchemaGeneratorHelper
SchemaGraph
SchemaGraphFactory
SchemaMissingError
SchemaParseOrder	This class will track what order SDLDefinition were parsed in via SchemaParser and TypeDefinitionRegistry
SchemaParser	This can take a graphql schema definition and parse it into a TypeDefinitionRegistry of definitions ready to be placed into SchemaGenerator say
SchemaPrinter	This can print an in memory GraphQL schema back to a logical schema definition
SchemaPrinter.Options	Options to use when printing a schema
SchemaProblem	A number of problems can occur when using the schema tools like SchemaParser or SchemaGenerator classes and they are reported via this exception as a list of GraphQLErrors
SchemaRedefinitionError
SchemaTransformer	Transforms a GraphQLSchema object by calling bac on a provided visitor.
SchemaTraverser
SchemaTypeChecker	This helps pre check the state of the type system to ensure it can be made into an executable schema.
SchemaUsage	This class shows schema usage information.
SchemaUsageSupport
SchemaUtil
SchemaValidationError
SchemaValidationErrorClassification	Error in graphql schema validation can have a classification, and all the error classifications implement this interface.
SchemaValidationErrorCollector
SchemaValidationErrorType
SchemaValidator
SDLDefinition<T extends SDLDefinition>	An interface for Schema Definition Language (SDL) definitions.
SDLExtensionDefinition	A marker interface for Schema Definition Language (SDL) extension definitions.
SDLNamedDefinition<T extends SDLNamedDefinition>	A interface for named Schema Definition Language (SDL) definition.
SelectedField	A SelectedField represents a field that occurred in a query selection set during execution and they are returned from using the DataFetchingFieldSelectionSet interface returned via DataFetchingEnvironment.getSelectionSet()
Selection<T extends Selection<T>>
SelectionSet
SelectionSet.Builder
SelectionSetContainer<T extends Node>
SerializationError
SimpleDataFetcherExceptionHandler	The standard handling of data fetcher error involves placing a ExceptionWhileDataFetching error into the error collection
SimpleFieldValidation	This very simple field validation will run the supplied function for a given field path and if it returns an error it will be added to the list of problems.
SimpleInstrumentation	Deprecated. use SimplePerformantInstrumentation instead as a base class.
SimpleInstrumentationContext<T>	A simple implementation of InstrumentationContext
SimpleListConnection<T>
SimplePerformantInstrumentation	An implementation of Instrumentation that does nothing.
SingleSubscriberPublisher<T>	A Publisher of things that are buffered and handles a single subscriber at a time.
SingleSubscriberPublisher.OnSubscriptionCallback	This is called when a subscription is made to the publisher
SourceLocation
StaticDataFetcher	A DataFetcher that always returns the same value
StreamedCall	Represents a call that fetches data that was streamed, via the @stream directive.
StreamPayload	Represents a stream payload
StreamPayload.Builder
StrictModeWiringException	An exception that is throw when RuntimeWiring.Builder.strictMode() or TypeRuntimeWiring.Builder.strictMode() is true and something gets redefined.
StringKit
StringValue
StringValue.Builder
StringValueParsing	Contains parsing code for the StringValue types in the grammar
StronglyConnectedComponentsTopologicallySorted	This class returns a list of strongly connected components (SCC) which are topologically sorted.
SubscriptionExecutionStrategy	An execution strategy that implements graphql subscriptions by using reactive-streams as the output result of the subscription query.
SubscriptionPublisher	Subscription queries return an instance of this class in the ExecutionResult data element for the subscribed field.
SubscriptionUniqueRootField	A subscription operation must only have one root field A subscription operation's single root field must not be an introspection field https://spec.graphql.org/draft/#sec-Single-root-field
ThreadSafe	This represents code that is known to be mutable but thread safe.
TracingInstrumentation	This Instrumentation implementation uses TracingSupport to capture tracing information and puts it into the ExecutionResult
TracingInstrumentation.Options
TracingSupport	This creates a map of tracing information as outlined in https://github.com/apollographql/apollo-tracing
TracingSupport.TracingContext	A simple object that you need to call TracingSupport.TracingContext.onEnd() on
TraversalContext
TraversalControl	Special traversal control values
Traverser<T>
TraverserContext<T>	Traversal context.
TraverserContext.Phase
TraverserResult
TraverserState<T>
TraverserState.EndList<U>
TraverserVisitor<T>
TraverserVisitorStub<T>
TreeParallelTransformer<T>
TreeParallelTraverser<T>
TreeTransformer<T>
TreeTransformerUtil
TrivialDataFetcher<T>	Mark a DataFetcher as trivial: If a data fetcher is simply mapping data from an object to a field, it can be considered a trivial data fetcher for the purposes of tracing and so on.
Type<T extends Type>
TypeAndFieldRule	The validation about GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType.
TypeDefinition<T extends TypeDefinition>	An interface for type definitions in a Schema Definition Language (SDL).
TypeDefinitionRegistry	A TypeDefinitionRegistry contains the set of type definitions that come from compiling a graphql schema definition file via SchemaParser.parse(String)
TypeExtensionDirectiveRedefinitionError
TypeExtensionEnumValueRedefinitionError
TypeExtensionFieldRedefinitionError
TypeExtensionMissingBaseTypeError
TypeFromAST
TypeInfo	This helper gives you access to the type info given a type definition
TypeKind	And enumeration of the the kind of things that can be in a graphql type system
TypeMismatchError
TypeName
TypeName.Builder
TypeRedefinitionError
TypeResolutionEnvironment	This is passed to a TypeResolver to help with object type resolution.
TypeResolutionParameters	This class is a classic builder style one that SHOULD have been on have been on TypeResolutionEnvironment but for legacy reasons was not.
TypeResolutionParameters.Builder
TypeResolver	This is called during type resolution to work out what concrete GraphQLObjectType should be used dynamically during runtime for GraphQLInterfaceTypes and GraphQLUnionTypes
TypeResolverProxy
TypeRuntimeWiring	A type runtime wiring is a specification of the data fetchers and possible type resolver for a given type name.
TypeRuntimeWiring.Builder
TypesImplementInterfaces	Schema validation rule ensuring object and interface types have all the fields that they need to implement the interfaces they say they implement.
TypeUtil	This class consists of static utility methods for operating on Type.
UnExecutableSchemaGenerator
UnicodeUtil	Contains Unicode helpers for parsing StringValue types in the grammar
UnionTypeDefinition
UnionTypeDefinition.Builder
UnionTypeError
UnionTypeExtensionDefinition
UnionTypeExtensionDefinition.Builder
UnionWiringEnvironment
UniqueArgumentNames	Unique argument names A GraphQL field or directive is only valid if all supplied arguments are uniquely named.
UniqueDirectiveNamesPerLocation	https://facebook.github.io/graphql/June2018/#sec-Directives-Are-Unique-Per-Location
UniqueFragmentNames
UniqueObjectFieldName
UniqueOperationNames	A GraphQL document is only valid if all defined operations have unique names.
UniqueVariableNames	Unique variable names
UnknownOperationException	This is thrown if multiple operations are defined in the query and the operation name is missing or there is no matching operation name contained in the GraphQL query.
UnresolvedTypeError
UnresolvedTypeException	This is thrown if a TypeResolver fails to give back a concrete type or provides a type that doesn't implement the given interface or union.
Util
ValidationContext
ValidationError
ValidationError.Builder
ValidationErrorClassification
ValidationErrorCollector
ValidationErrorType
ValidationUtil
Validator
Value<T extends Value>
ValuesResolver
ValuesResolver.ValueMode
ValueToVariableValueCompiler
ValueTraverser	This class allows you to traverse a set of input values according to the type system and optional change the values present.
ValueUnboxer	A value unboxer takes values that are wrapped in classes like Optional / OptionalInt etc..
ValueVisitor	A visitor callback used by ValueTraverser
ValueVisitor.InputElements	Represents the elements that leads to a value and type
VariableAccumulator	This accumulator class decides on whether to create a variable for a query argument and if so it tracks what variables were made.
VariableDefaultValuesOfCorrectType
VariableDefinition
VariableDefinition.Builder
VariablePredicate	This predicate indicates whether a variable should be made for this field argument OR whether it will be compiled into a graphql AST literal.
VariableReference
VariableReference.Builder
VariablesAreInputTypes
VariablesTypesMatcher
VariableTypesMatch
VariableValueWithDefinition
Vertex
Vertex.VertexData
VisibleFieldPredicate	Predicate used during a FieldVisibilitySchemaTransformation to test whether a field should be visible.
VisibleFieldPredicateEnvironment	Container to pass additional context about a schema element (ie., field) to VisibleFieldPredicate.
VisibleFieldPredicateEnvironment.VisibleFieldPredicateEnvironmentImpl
VisibleForTesting	Marks fields, methods etc as more visible than actually needed for testing purposes.
WiringFactory	A WiringFactory allows you to more dynamically wire in TypeResolvers and DataFetchers based on the IDL definitions.