Uses of Class
graphql.PublicApi

Packages that use PublicApi

Package	Description
graphql
graphql.analysis
graphql.analysis.values
graphql.execution
graphql.execution.directives
graphql.execution.instrumentation
graphql.execution.instrumentation.dataloader
graphql.execution.instrumentation.fieldvalidation
graphql.execution.instrumentation.parameters
graphql.execution.instrumentation.tracing
graphql.execution.preparsed
graphql.execution.preparsed.persisted
graphql.execution.reactive
graphql.extensions
graphql.introspection
graphql.language
graphql.normalized
graphql.parser
graphql.relay
graphql.schema
graphql.schema.diff
graphql.schema.diff.reporting
graphql.schema.idl
graphql.schema.idl.errors
graphql.schema.transform
graphql.schema.usage
graphql.schema.validation
graphql.schema.visibility
graphql.schema.visitor
graphql.util
graphql.validation

Uses of PublicApi in graphql

Classes in graphql with annotations of type PublicApi

Modifier and Type	Class	Description
class	AssertException
class	Directives	The directives that are understood by graphql-java
interface	ErrorClassification	Errors in graphql-java can have a classification to help with the processing of errors.
class	ErrorType	All the errors in graphql belong to one of these categories
class	ExceptionWhileDataFetching	This graphql error will be used if a runtime exception is encountered while a data fetcher is invoked
class	ExecutionInput	This represents the series of values that can be input on a graphql query execution
interface	ExecutionResult	This simple value class represents the result of performing a graphql query.
class	GraphQL	This class is where all graphql-java query execution begins.
static class	GraphQL.Builder
class	GraphQLContext	This context object can be used to contain key values that can be useful as "context" when executing DataFetchers
interface	GraphQLError	The interface describing graphql errors NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
class	GraphqlErrorBuilder<B extends GraphqlErrorBuilder<B>>	This helps you build GraphQLErrors and also has a quick way to make a DataFetcherResults from that error.
class	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.
class	ParseAndValidate	This class allows you to parse and validate a graphql query without executing it.
class	ParseAndValidateResult	A result object used in ParseAndValidate helper that indicates the outcomes of a parse and validate operation.
class	Scalars	This contains the implementations of the Scalar types that ship with graphql-java.
class	SerializationError
class	TypeMismatchError
class	TypeResolutionEnvironment	This is passed to a TypeResolver to help with object type resolution.
class	UnresolvedTypeError

Uses of PublicApi in graphql.analysis

Classes in graphql.analysis with annotations of type PublicApi

Modifier and Type	Interface	Description
interface	FieldComplexityCalculator	Used to calculate the complexity of a field.
class	FieldComplexityEnvironment
class	MaxQueryComplexityInstrumentation	Prevents execution if the query complexity is greater than the specified maxComplexity.
class	MaxQueryDepthInstrumentation	Prevents execution if the query depth is greater than the specified maxDepth.
class	QueryComplexityCalculator	This can calculate the complexity of an operation using the specified FieldComplexityCalculator you pass into it.
class	QueryComplexityInfo	The query complexity info.
static class	QueryComplexityInfo.Builder
class	QueryDepthInfo	The query depth info.
static class	QueryDepthInfo.Builder
interface	QueryReducer<T>	Used by QueryTraverser to reduce the fields of a Document (or part of it) to a single value.
class	QueryTransformer	Helps to transform a Document (or parts of it) and tracks at the same time the corresponding Schema types.
static class	QueryTransformer.Builder
class	QueryTraverser	Helps to traverse (or reduce) a Document (or parts of it) and tracks at the same time the corresponding Schema types.
static class	QueryTraverser.Builder
interface	QueryVisitor	Used by QueryTraverser to visit the nodes of a Query.
interface	QueryVisitorFieldArgumentEnvironment
interface	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.
interface	QueryVisitorFieldArgumentValueEnvironment
interface	QueryVisitorFieldEnvironment
interface	QueryVisitorFragmentDefinitionEnvironment
interface	QueryVisitorFragmentSpreadEnvironment
interface	QueryVisitorInlineFragmentEnvironment
class	QueryVisitorStub

Uses of PublicApi in graphql.analysis.values

Classes in graphql.analysis.values with annotations of type PublicApi

Modifier and Type	Class	Description
class	ValueTraverser	This class allows you to traverse a set of input values according to the type system and optional change the values present.

Uses of PublicApi in graphql.execution

Classes in graphql.execution with annotations of type PublicApi

Modifier and Type	Class	Description
class	AbortExecutionException	This Exception indicates that the current execution should be aborted.
class	AsyncExecutionStrategy	The standard graphql execution strategy that runs fields asynchronously non-blocking.
class	AsyncSerialExecutionStrategy	Async non-blocking execution, but serial: only one field at the time will be resolved.
class	CoercedVariables	Holds coerced variables, that is their values are now in a canonical form.
class	DataFetcherExceptionHandlerParameters	The parameters available to DataFetcherExceptionHandlers
class	DataFetcherExceptionHandlerResult	The result object for DataFetcherExceptionHandlers
class	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.
class	DefaultValueUnboxer	Public API because it should be used as a delegate when implementing a custom ValueUnboxer
class	ExecutionContext
class	ExecutionContextBuilder
class	ExecutionId	This opaque identifier is used to identify a unique query execution
class	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.
class	ExecutionStrategyParameters	The parameters that are passed to execution strategies
class	FetchedValue	Note: This is returned by InstrumentationFieldCompleteParameters.getFetchedValue() and therefore part of the public despite never used in a method signature.
class	FieldValueInfo
class	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.
class	MergedField	This represents all Fields in a query which overlap and are merged into one.
class	MergedSelectionSet
class	MissingRootTypeException	This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
class	NonNullableValueCoercedAsNullException	This is thrown if a non nullable value is coerced to a null value
class	OneOfNullValueException	The input map to One Of Input Types MUST only have 1 entry with a non null value
class	OneOfTooManyKeysException	The input map to One Of Input Types MUST only have 1 entry
class	RawVariables	Holds raw variables, which have not been coerced yet into CoercedVariables
class	ResultNodesInfo	This class is used to track the number of result nodes that have been created during execution.
class	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.
class	SimpleDataFetcherExceptionHandler	The standard handling of data fetcher error involves placing a ExceptionWhileDataFetching error into the error collection
class	SubscriptionExecutionStrategy	An execution strategy that implements graphql subscriptions by using reactive-streams as the output result of the subscription query.
class	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.
class	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.

Uses of PublicApi in graphql.execution.directives

Classes in graphql.execution.directives with annotations of type PublicApi

Modifier and Type	Class	Description
class	QueryAppliedDirective	An applied directive represents the instance of a directive that is applied to a query element such as a field or fragment.
class	QueryAppliedDirectiveArgument	This represents the argument values that can be placed on an QueryAppliedDirective.
interface	QueryDirectives	This gives you access to the immediate directives on a MergedField.

Uses of PublicApi in graphql.execution.instrumentation

Classes in graphql.execution.instrumentation with annotations of type PublicApi

Modifier and Type	Class	Description
class	ChainedInstrumentation	This allows you to chain together a number of Instrumentation implementations and run them in sequence.
class	DocumentAndVariables
class	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.
class	SimpleInstrumentation	Deprecated. use SimplePerformantInstrumentation instead as a base class.
class	SimpleInstrumentationContext<T>	A simple implementation of InstrumentationContext
class	SimplePerformantInstrumentation	An implementation of Instrumentation that does nothing.

Uses of PublicApi in graphql.execution.instrumentation.dataloader

Classes in graphql.execution.instrumentation.dataloader with annotations of type PublicApi

Modifier and Type	Class	Description
class	DataLoaderDispatcherInstrumentation	This graphql Instrumentation will dispatch all the contained DataLoaders when each level of the graphql query is executed.
class	DataLoaderDispatcherInstrumentationOptions	The options that control the operation of DataLoaderDispatcherInstrumentation
class	DataLoaderDispatcherInstrumentationState	A base class that keeps track of whether aggressive batching can be used

Uses of PublicApi in graphql.execution.instrumentation.fieldvalidation

Classes in graphql.execution.instrumentation.fieldvalidation with annotations of type PublicApi

Modifier and Type	Interface	Description
interface	FieldAndArguments	This represents a field and its arguments that may be validated.
interface	FieldValidationEnvironment	This contains all of the field and their arguments for a given query.
class	FieldValidationInstrumentation	This Instrumentation allows you to validate the fields of the query before the query is executed.
class	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.

Uses of PublicApi in graphql.execution.instrumentation.parameters

Classes in graphql.execution.instrumentation.parameters with annotations of type PublicApi

Modifier and Type	Class	Description
class	InstrumentationCreateStateParameters	Parameters sent to Instrumentation methods
class	InstrumentationExecuteOperationParameters	Parameters sent to Instrumentation methods
class	InstrumentationExecutionParameters	Parameters sent to Instrumentation methods
class	InstrumentationExecutionStrategyParameters	Parameters sent to Instrumentation methods
class	InstrumentationFieldCompleteParameters	Parameters sent to Instrumentation methods
class	InstrumentationFieldFetchParameters	Parameters sent to Instrumentation methods
class	InstrumentationFieldParameters	Parameters sent to Instrumentation methods
class	InstrumentationValidationParameters	Parameters sent to Instrumentation methods

Uses of PublicApi in graphql.execution.instrumentation.tracing

Classes in graphql.execution.instrumentation.tracing with annotations of type PublicApi

Modifier and Type	Class	Description
class	TracingInstrumentation	This Instrumentation implementation uses TracingSupport to capture tracing information and puts it into the ExecutionResult
class	TracingSupport	This creates a map of tracing information as outlined in https://github.com/apollographql/apollo-tracing

Uses of PublicApi in graphql.execution.preparsed

Classes in graphql.execution.preparsed with annotations of type PublicApi

Modifier and Type	Class	Description
class	PreparsedDocumentEntry	An instance of a preparsed document entry represents the result of a query parse and validation.

Uses of PublicApi in graphql.execution.preparsed.persisted

Classes in graphql.execution.preparsed.persisted with annotations of type PublicApi

Modifier and Type	Class	Description
class	ApolloPersistedQuerySupport	This persisted query support class supports the Apollo scheme where the persisted query id is in ExecutionInput.getExtensions().
class	InMemoryPersistedQueryCache	A PersistedQueryCache that is just an in memory map of known queries.
interface	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.
class	PersistedQueryIdInvalid
class	PersistedQueryNotFound	An exception that indicates the query id is not valid and can be found ever in cache

Uses of PublicApi in graphql.execution.reactive

Classes in graphql.execution.reactive with annotations of type PublicApi

Modifier and Type	Class	Description
class	DelegatingSubscription	A simple subscription that delegates to another
class	SubscriptionPublisher	Subscription queries return an instance of this class in the ExecutionResult data element for the subscribed field.

Uses of PublicApi in graphql.extensions

Classes in graphql.extensions with annotations of type PublicApi

Modifier and Type	Class	Description
class	ExtensionsBuilder	This class can be used to help build the graphql `extensions` map.

Uses of PublicApi in graphql.introspection

Classes in graphql.introspection with annotations of type PublicApi

Modifier and Type	Class	Description
class	GoodFaithIntrospection	This Instrumentation ensure that a submitted introspection query is done in good faith.
class	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.
interface	IntrospectionQuery
class	IntrospectionQueryBuilder	IntrospectionQueryBuilder allows you to build introspection queries controlled by the options you specify
class	IntrospectionResultToSchema
class	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.
static interface	IntrospectionWithDirectivesSupport.DirectivePredicateEnvironment	The parameter environment on a call to IntrospectionWithDirectivesSupport.DirectivePredicate

Uses of PublicApi in graphql.language

Classes in graphql.language with annotations of type PublicApi

Modifier and Type	Class	Description
class	AbstractDescribedNode<T extends Node>
class	AbstractNode<T extends Node>
class	Argument
class	ArrayValue
class	AstNodeAdapter	Adapts an Ast node to the general node from the util package
class	AstPrinter	This can take graphql language AST and print it out as a string
class	AstSignature	This will produce signature and privacy safe query documents that can be used for query categorisation and logging.
class	AstSorter	A class that helps you sort AST nodes
class	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.
class	BooleanValue
class	Comment	A single-line comment.
interface	Definition<T extends Definition>
interface	DescribedNode<T extends Node>	Represents a node that can contain a description.
class	Description
class	Directive
class	DirectiveDefinition
class	DirectiveLocation
interface	DirectivesContainer<T extends DirectivesContainer>	Represents a language node that can contain Directives.
class	Document
class	EnumTypeDefinition
class	EnumTypeExtensionDefinition
class	EnumValue
class	EnumValueDefinition
class	Field
class	FieldDefinition
class	FloatValue
class	FragmentDefinition	Provided to the DataFetcher, therefore public API
class	FragmentSpread
class	IgnoredChar	Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
class	IgnoredChars	Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
interface	ImplementingTypeDefinition<T extends TypeDefinition>	A TypeDefinition that might implement interfaces
class	InlineFragment
class	InputObjectTypeDefinition
class	InputObjectTypeExtensionDefinition
class	InputValueDefinition
class	InterfaceTypeDefinition
class	InterfaceTypeExtensionDefinition
class	IntValue
class	ListType
interface	NamedNode<T extends NamedNode>	Represents a language node that has a name
interface	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.
interface	NodeBuilder
class	NodeChildrenContainer	Container of children of a Node.
interface	NodeDirectivesBuilder
class	NodeParentTree<T extends Node>	This represents a hierarchy from a graphql language node upwards to its associated parent nodes.
class	NodeTraverser	Lets you traverse a Node tree.
interface	NodeVisitor	Used by NodeTraverser to visit Node.
class	NodeVisitorStub	Convenient implementation of NodeVisitor for easy subclassing methods handling different types of Nodes in one method.
class	NonNullType
class	NullValue
class	ObjectField
class	ObjectTypeDefinition
class	ObjectTypeExtensionDefinition
class	ObjectValue
class	OperationDefinition
class	OperationTypeDefinition
class	ScalarTypeDefinition
class	ScalarTypeExtensionDefinition
interface	ScalarValue<T extends Value>
class	SchemaDefinition
class	SchemaExtensionDefinition
interface	SDLDefinition<T extends SDLDefinition>	An interface for Schema Definition Language (SDL) definitions.
interface	SDLExtensionDefinition	A marker interface for Schema Definition Language (SDL) extension definitions.
interface	SDLNamedDefinition<T extends SDLNamedDefinition>	A interface for named Schema Definition Language (SDL) definition.
interface	Selection<T extends Selection<T>>
class	SelectionSet
interface	SelectionSetContainer<T extends Node>
class	SourceLocation
class	StringValue
interface	Type<T extends Type>
interface	TypeDefinition<T extends TypeDefinition>	An interface for type definitions in a Schema Definition Language (SDL).
class	TypeKind	And enumeration of the the kind of things that can be in a graphql type system
class	TypeName
class	UnionTypeDefinition
class	UnionTypeExtensionDefinition
interface	Value<T extends Value>
class	VariableDefinition
class	VariableReference

Uses of PublicApi in graphql.normalized

Classes in graphql.normalized with annotations of type PublicApi

Modifier and Type	Class	Description
class	ExecutableNormalizedField	An ExecutableNormalizedField represents a field in an executable graphql operation.
class	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.
class	ExecutableNormalizedOperationFactory	This factory can create a ExecutableNormalizedOperation which represents what would be executed during a given graphql operation.
class	ExecutableNormalizedOperationToAstCompiler	This class can take a list of ExecutableNormalizedFields and compiling out a normalised operation Document that would represent how those fields maybe executed.
class	NormalizedInputValue	An argument value with type information.

Uses of PublicApi in graphql.parser

Classes in graphql.parser with annotations of type PublicApi

Modifier and Type	Class	Description
class	InvalidSyntaxException	This exception is thrown by the Parser if the graphql syntax is not valid
class	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.
class	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
interface	ParserEnvironment	This is the arguments that can be passed to a Parser
class	ParserOptions	Options that control how the Parser behaves.

Uses of PublicApi in graphql.relay

Classes in graphql.relay with annotations of type PublicApi

Modifier and Type	Interface	Description
interface	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.
interface	ConnectionCursor	Represents a connection cursor in Relay which is an opaque string that the server understands.
class	DefaultConnection<T>	A default implementation of Connection
class	DefaultConnectionCursor
class	DefaultEdge<T>
class	DefaultPageInfo
interface	Edge<T>	Represents an edge in Relay which is essentially a node of data T and the cursor for that node.
interface	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
class	Relay	This can be used to compose graphql runtime types that implement that Relay specification.
class	SimpleListConnection<T>

Uses of PublicApi in graphql.schema

Classes in graphql.schema with annotations of type PublicApi

Modifier and Type	Class	Description
class	AsyncDataFetcher<T>	A modifier type that indicates the underlying data fetcher is run asynchronously
class	CoercingParseLiteralException
class	CoercingParseValueException
class	CoercingSerializeException
class	DataFetcherFactories	A helper for DataFetcherFactory
class	DataFetcherFactoryEnvironment	This is passed to a DataFetcherFactory when it is invoked to get a DataFetcher
interface	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
interface	DataFetchingFieldSelectionSet	This class allows you to retrieve the selection set of fields that have been asked for when the DataFetcher was invoked.
class	DefaultGraphqlTypeComparatorRegistry	Associates a Comparator with a GraphqlTypeComparatorEnvironment to control the scope in which the Comparator can be applied.
class	DelegatingDataFetchingEnvironment	DelegatingDataFetchingEnvironment implements DataFetchingEnvironment by delegating to an underlying instance.
class	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.
class	GraphQLAppliedDirective	An applied directive represents the instance of a directive that is applied to a schema element, as opposed to it definition
class	GraphQLAppliedDirectiveArgument	This represents the argument values that can be placed on an GraphQLAppliedDirective.
class	GraphQLArgument	This defines an argument that can be supplied to a graphql field (via GraphQLFieldDefinition.
class	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
interface	GraphQLCompositeType
class	GraphQLDirective	A directive can be used to modify the behavior of a graphql field or type.
interface	GraphQLDirectiveContainer	Represents a graphql runtime type that can have GraphQLAppliedDirectives.
class	GraphqlElementParentTree	This represents a hierarchy an graphql runtime element upwards to its associated parent elements.
class	GraphQLEnumType	A graphql enumeration type has a limited set of values.
class	GraphQLEnumValueDefinition	A graphql enumeration type has a limited set of values and this defines one of those unique values
static class	GraphQLEnumValueDefinition.Builder
class	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.
static class	GraphQLFieldDefinition.Builder
interface	GraphQLFieldsContainer	Types that can contain output fields are marked with this interface
interface	GraphQLImplementingType	A GraphQLType which can implement interfaces
interface	GraphQLInputFieldsContainer	Types that can contain input fields are marked with this interface
class	GraphQLInputObjectField	Input objects defined via GraphQLInputObjectType contains these input fields.
static class	GraphQLInputObjectField.Builder
class	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.
static class	GraphQLInputObjectType.Builder
interface	GraphQLInputSchemaElement	A schema element that is concerned with input.
interface	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.
interface	GraphQLInputValueDefinition	Named schema elements that contain input type information.
class	GraphQLInterfaceType	In graphql, an interface is an abstract type that defines the set of fields that a type must include to implement that interface.
static class	GraphQLInterfaceType.Builder
class	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.
interface	GraphQLModifiedType	A modified type wraps another graphql type and modifies it behavior
interface	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.
interface	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.
interface	GraphQLNamedSchemaElement	A Schema element which has a name and also a description and AST Node which it is based on.
interface	GraphQLNamedType	A GraphQLType which is also a named element, which means it has a getName() method.
class	GraphQLNonNull	A modified type that indicates there the underlying wrapped type will not be null.
interface	GraphQLNullableType
class	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.
static class	GraphQLObjectType.Builder
interface	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.
class	GraphQLScalarType	A scalar type is a leaf node in the graphql tree of types.
static class	GraphQLScalarType.Builder
class	GraphQLSchema	The schema represents the combined type system of the graphql engine.
interface	GraphQLSchemaElement	A GraphQLSchema can be viewed as a graph of GraphQLSchemaElement.
interface	GraphQLType	A type inside the GraphQLSchema.
class	GraphqlTypeComparatorEnvironment	Defines the scope to control where the registered Comparator can be applied.
interface	GraphqlTypeComparatorRegistry
class	GraphQLTypeReference	A special type to allow a object/interface types to reference itself.
class	GraphQLTypeUtil	A utility class that helps work with GraphQLTypes
interface	GraphQLTypeVisitor	GraphQLTypeVisitor can be used to visit all the elements of a schema (types, fields, directives and so on) in a visitor pattern.
class	GraphQLTypeVisitorStub	Base implementation of GraphQLTypeVisitor for convenience.
class	GraphQLUnionType	A union type is a polymorphic type that dynamically represents one of more concrete object types.
static class	GraphQLUnionType.Builder
interface	GraphQLUnmodifiedType
class	InputValueWithState	Used by @GraphQLArgument and GraphQLInputObjectField to represent different value states.
class	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.
class	SchemaElementChildrenContainer
class	SchemaTransformer	Transforms a GraphQLSchema object by calling bac on a provided visitor.
class	SchemaTraverser
interface	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()
class	StaticDataFetcher	A DataFetcher that always returns the same value

Uses of PublicApi in graphql.schema.diff

Classes in graphql.schema.diff with annotations of type PublicApi

Modifier and Type	Class	Description
class	DiffCategory	A classification of difference events.
class	DiffEvent	This represents the events that the SchemaDiff outputs.
class	DiffLevel	This is the level of difference between graphql APIs
class	DiffSet	Deprecated.
class	SchemaDiffSet	Interface used to define 2 schemas that can be diffed by the SchemaDiff operation.

Uses of PublicApi in graphql.schema.diff.reporting

Classes in graphql.schema.diff.reporting with annotations of type PublicApi

Modifier and Type	Class	Description
class	CapturingReporter	A reporter that captures all the difference events as they occur
class	ChainedReporter	A reporter that chains together one or more difference reporters
class	PrintStreamReporter	A reporter that prints its output to a PrintStream

Uses of PublicApi in graphql.schema.idl

Classes in graphql.schema.idl with annotations of type PublicApi

Modifier and Type	Class	Description
class	CombinedWiringFactory	This combines a number of WiringFactorys together to act as one.
class	DirectiveInfo	Info on all the directives provided by graphql specification
class	FieldWiringEnvironment
class	InterfaceWiringEnvironment
class	MapEnumValuesProvider
class	MockedWiringFactory
class	NaturalEnumValuesProvider<T extends java.lang.Enum<T>>	Simple EnumValuesProvided which maps the GraphQL Enum name to the Java Enum instance.
class	RuntimeWiring	A runtime wiring is a specification of data fetchers, type resolvers and custom scalars that are needed to wire together a functional GraphQLSchema
static class	RuntimeWiring.Builder
class	ScalarInfo	Info on all the standard scalar objects provided by graphql-java
class	ScalarWiringEnvironment
interface	SchemaDirectiveWiring	A SchemaDirectiveWiring is responsible for enhancing a runtime element based on directives placed on that element in the Schema Definition Language (SDL).
interface	SchemaDirectiveWiringEnvironment<T extends GraphQLDirectiveContainer>	SchemaDirectiveWiring is passed this object as parameters when it builds out behaviour
class	SchemaGenerator	This can generate a working runtime schema from a type registry and runtime wiring
class	SchemaParser	This can take a graphql schema definition and parse it into a TypeDefinitionRegistry of definitions ready to be placed into SchemaGenerator say
class	SchemaPrinter	This can print an in memory GraphQL schema back to a logical schema definition
class	TypeDefinitionRegistry	A TypeDefinitionRegistry contains the set of type definitions that come from compiling a graphql schema definition file via SchemaParser.parse(String)
class	TypeRuntimeWiring	A type runtime wiring is a specification of the data fetchers and possible type resolver for a given type name.
class	UnionWiringEnvironment
(package private) class	WiringEnvironment

Uses of PublicApi in graphql.schema.idl.errors

Classes in graphql.schema.idl.errors with annotations of type PublicApi

Modifier and Type	Class	Description
class	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

Uses of PublicApi in graphql.schema.transform

Classes in graphql.schema.transform with annotations of type PublicApi

Modifier and Type	Class	Description
class	FieldVisibilitySchemaTransformation	Transforms a schema by applying a visibility predicate to every field.
interface	VisibleFieldPredicateEnvironment	Container to pass additional context about a schema element (ie., field) to VisibleFieldPredicate.

Uses of PublicApi in graphql.schema.usage

Classes in graphql.schema.usage with annotations of type PublicApi

Modifier and Type	Class	Description
class	SchemaUsage	This class shows schema usage information.
class	SchemaUsageSupport

Uses of PublicApi in graphql.schema.validation

Classes in graphql.schema.validation with annotations of type PublicApi

Modifier and Type	Interface	Description
interface	SchemaValidationErrorClassification	Error in graphql schema validation can have a classification, and all the error classifications implement this interface.

Uses of PublicApi in graphql.schema.visibility

Classes in graphql.schema.visibility with annotations of type PublicApi

Modifier and Type	Class	Description
class	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.
class	DefaultGraphqlFieldVisibility	The default field visibility of graphql-java is that everything is visible
interface	GraphqlFieldVisibility	This allows you to control the visibility of graphql fields.
class	NoIntrospectionGraphqlFieldVisibility	Deprecated. This is no longer the best way to prevent Introspection - Introspection.enabledJvmWide(boolean) can be used instead

Uses of PublicApi in graphql.schema.visitor

Classes in graphql.schema.visitor with annotations of type PublicApi

Modifier and Type	Class	Description
class	GraphQLSchemaTraversalControl	This indicates what traversal control to apply during the visitation and can be created via calls to methods like GraphQLSchemaVisitorEnvironment.ok() or GraphQLSchemaVisitorEnvironment.changeNode(GraphQLSchemaElement) say

Uses of PublicApi in graphql.util

Classes in graphql.util with annotations of type PublicApi

Modifier and Type	Class	Description
class	Anonymizer	Util class which converts schemas and optionally queries into anonymized schemas and queries.
class	Breadcrumb<T>	A specific NodeLocation inside a node.
interface	NodeAdapter<T>	Adapts an arbitrary class to behave as a node.
class	NodeLocation	General position of a Node inside a parent.
class	NodeMultiZipper<T>
class	NodeZipper<T>
class	TraversalControl	Special traversal control values
interface	TraverserContext<T>	Traversal context.
class	TreeTransformer<T>
class	TreeTransformerUtil

Uses of PublicApi in graphql.validation

Classes in graphql.validation with annotations of type PublicApi

Modifier and Type	Class	Description
class	ValidationError
interface	ValidationErrorClassification
class	ValidationErrorType