h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                         Safe graphql8Where directives can appear in a type system definition. graphqlWhere directives can appear in an executable definition, like a query.graphqlAll directives can be splitted in two groups: directives used to annotate various parts of executable definitions and the ones used in the schema definition.       Safe #$%"2'graphql#Single value in an enum definition. 1enum Direction { NORTH EAST SOUTH WEST } "NORTH, EAST, SOUTH, and WEST3 are value definitions of an enum type definition  Direction.graphqlList of types forming a union. $union SearchResult = Person | Photo Person and Photo are member types of the union  SearchResult.!graphqlDefines an input value.-Input values can define field arguments, see #.All kinds of definitions that can occur in a GraphQL document.graphqlGraphQL document.graphql(Contains some tree node with a location.graphql Error location, line and column.graphqlName.graphqlEscapes a single character according to the GraphQL escaping rules for double-quoted string values.Characters, that should be escaped, are written as escaped characters with a backslash or Unicode with an "\u". Other characters are returned as strings. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGIHJKLMNOPQRSTUVWXZ[Y\^_]`abcdeihglnkmfjopqrstuvwxyz{|}~rs#$\^_]`abcd=>KLxy%&pqtu'(vw!"PMNOWXZ[YBC?@Az{|}~QRSTo6789:;<)*+,-./012345GIHJDEF eihglnkmfjUVSafe #$%graphqlInstructs the encoder whether the GraphQL document should be minified or pretty printed.Use  or  to construct the formatter.graphql+Constructs a formatter for pretty printing.graphql%Constructs a formatter for minifying.graphql#Converts a Document' into a string.graphql Converts a  into a string.graphql Converts a K into a string.graphql Converts a e into a string.graphql Converts a Q a type into a string. Safe-Inferred *Igraphql7Standard parser. Accepts the type of the parsed token.graphqlParser that skips comments and meaningless characters, whitespaces and commas.graphqlParser for comments.graphql7Lexeme definition which ignores whitespaces and commas.graphql7Symbol definition which ignores whitespaces and commas.graphqlParser for "!".graphqlParser for "$".graphqlParser for "@".graphqlParser for "&".graphqlParser for ":".graphqlParser for "=".graphql%Parser for the spread operator (...).graphqlParser for "|".graphql-Parser for an expression between "(" and ")".graphql-Parser for an expression between "[" and "]".graphql-Parser for an expression between "{" and "}".graphqlParser for strings.graphqlParser for block strings.graphqlParser for integers.graphql"Parser for floating-point numbers.graphqlParser for names ([_A-Za-z][_0-9A-Za-z]*).graphql!Parser for the "Byte Order Mark".graphqlParses "extend" followed by a ". It is used by schema extensions. Safe-Inferred #$+graphql!Parser for the GraphQL documents. Safe-Inferred+, !"#$%&'()543210/.-,*+6<;:978=>?@ABCDEFGJIHKLMNOPQTRSUVWXYZ[\dcba`]^_ejfmknlgihopqrstuvwxyz}{|~None1/ graphqlThis map associates values with the given text keys. Insertion order is preserved. When inserting a value with a key, that is already available in the map, the existing value isn't overridden, but combined with the new value using its  instance.Internally this map uses an array with keys to preserve the order and an unorded map with key-value pairs.graphql'Constructs a map with a single element.graphqlConstructs an empty map.graphqlReduces this map by applying a binary operator from left to right to all elements, using the given starting value.graphql+Traverse over the elements and collect the  results.graphql1Converts this map to the list of key-value pairs.graphql)Returns a list with all keys in this map.graphql-Returns a list with all elements in this map.graphqlAssociates the specified value with the specified key in this map. If this map previously contained a mapping for the key, the existing and new values are combined.graphqlAssociates the specified value with the specified key in this map. If this map previously contained a mapping for the key, the existing value is replaced by the new one.graphql:Gives the size of this map, i.e. number of elements in it.graphql$Looks up a value in this map by key.   Safe-Inferred 8graphql Directive.graphql$Enum value is a single member of an .graphqlEnum type definition.Some leaf values of requests and input values are Enums. GraphQL serializes Enum values as strings, however internally Enums can be represented by any kind of type, often integers.graphqlScalar type definition.The leaf values of any request and input values to arguments are Scalars (or Enums) .graphqlArgument list.graphqlContains variables for the query. The key of the map is a variable name, and the value is the variable value.graphql,Represents accordingly typed GraphQL values.graphql"GraphQL Float is double precision.graphqlArbitrary nested list.graphqlThe String scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.graphqlThe Boolean scalar type represents true or false.graphqlThe Int scalar type represents non-fractional signed whole numeric values. Int can represent values between -2^{31} and  2^{31 - 1}.graphqlThe Float scalar type represents signed double-precision fractional values as specified by  1https://en.wikipedia.org/wiki/IEEE_floating_pointIEEE 754.graphqlThe ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as "4") or integer (such as 4)) input value will be accepted as an ID.graphqlTakes a list of directives, handles supported directives and excludes them from the result. If the selection should be skipped, returns . Safe-Inferred&< graphqlField argument definitions.graphqlField argument definition.graphqlThese types may be used as input types for arguments and directives.GraphQL distinguishes between "wrapping" and "named" types. Each wrapping type can wrap other wrapping or named types. Wrapping types are lists and Non-Null types (named types are nullable by default).graphqlInput object type definition.An input object defines a structured collection of fields which may be supplied to a field argument.graphqlSingle field of an .graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphql7Checks whether the given input type is a non-null type. None&F;graphql' associates some function(s) with each .  resolves a  into a .  resolves additionally a  into a 1 if it is the field of a root subscription type.!The resolvers aren't part of the  itself because not all fields have resolvers (interface fields don't have an implementation).graphqlA source stream represents the sequence of events, each of which will trigger a GraphQL execution corresponding to that event.graphqlMonad transformer stack used by the resolvers for determining the resolved event stream of a subscription field.graphqlMonad transformer stack used by the resolvers for determining the resolved value of a field.graphql?Resolution context holds resolver arguments and the root value.graphqlThese types may be used as output types as the result of fields.GraphQL distinguishes between "wrapping" and "named" types. Each wrapping type can wrap other wrapping or named types. Wrapping types are lists and Non-Null types (named types are nullable by default).graphqlOutput object field definition.graphqlUnion Type Definition.When a field can return one of a heterogeneous set of types, a Union type is used to describe what types are possible.graphqlInterface Type Definition.When a field can return one of a heterogeneous set of types, a Interface type is used to describe what types are possible, and what fields are in common across all types.graphqlObject type definition.Almost all of the GraphQL types you define will be object types. Object types have a name, but most importantly describe their fields.graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphqlMatches either  or .graphql8Checks whether the given output type is a non-null type.graphqlRetrieves an argument by its name. If the argument with this name couldn't be found, returns 5 (i.e. the argument is assumed to be optional then).graphql Description.graphql Field type.graphql Arguments.''NoneJ graphql?These types may describe the parent context of a selection set.graphql?These types may describe the parent context of a selection set.graphqlA Schema is created by supplying the root types of each type of operation, query and mutation (optional). A schema definition is then supplied to the validator and executor.graphqlDirective definitions.graphqlDirective definition.graphql-These are all of the possible kinds of types.graphqlSchema description.graphqlSchema query type.graphqlSchema mutation type.graphqlSchema subscription type.graphqlSchema directive definitions.graphqlTypes referenced by the schema.graphqlInterface implementations.graphql Description.graphqlQuery.graphql Mutation.graphql Subscription.graphql DirectivesgraphqlTypes. Interface implementations (used only for faster access).! None NgraphqlSchema constructor.Note: When the schema is constructed, by default only the types that are reachable by traversing the root types are included, other types must be explicitly referenced using  instead.graphqlConstructs a complete schema, including user-defined types not referenced in the schema directly (for example interface implementations).graphql Query type.graphqlMutation type.graphqlSubscription type.graphqlDirective definitions.graphqlSchema.graphqlSchema descriptiongraphql Query type.graphqlMutation type.graphqlSubscription type.graphqlAdditional types.graphqlDirective definitions.graphqlSchema.NoneNo44 None &[#graphql&Intermediate type used to serialize a GraphQL value.4The serialization is done during the execution, and ' contains already serialized data (in  and ) as well as the new layer that has to be serialized in the current step. So / is parameterized by the serialization format.graphql describes how a GraphQL value should be serialized.graphql Serializes a GraphQL4 value according to the given serialization format.Type infomration is given as a hint, e.g. if you need to know what type is being serialized to serialize it properly. Don't do any validation for GraphQL built-in types here.If the value cannot be serialized without losing information, return  @ it will cause a field error.graphqlSince variables are passed separately from the query, in an independent format, they should be first coerced to the internal representation used by this implementation.graphqlOnly a basic, format-specific, coercion must be done here. Type correctness or nullability shouldn't be validated here, they will be validated later. The type information is provided only as a hint. For example GraphQL= prohibits the coercion from a 't:Float' to an 't:Int', but JSON doesn't have integers, so whole numbers should be coerced to 't:Int` when receiving variables as a JSON object. The same holds for 't:Enum'. There are formats that support enumerations, JSON0 doesn't, so the type information is given and  can check that an 't:Enum' is expected and treat the given value appropriately. Even checking whether this value is a proper member of the corresponding 't:Enum' type isn't required here, since this can be checked independently.Another example is an ID. GraphQL6 explicitly allows to coerce integers and strings to ID s, so if an ID is received as an integer, it can be left as is and will be coerced later.9If a value cannot be coerced without losing information,  should be returned, the coercion will fail then and the query won't be executed.graphqlLooks up a value by name in the given map, coerces it and inserts into the result map. If the coercion fails, returns . If the value isn't given, but a default value is known, inserts the default value into the result map. Otherwise it fails with  if the Input Type is a Non-Nullable type, or returns the unchanged, original map.graphqlCoerces operation arguments according to the input coercion rules for the corresponding types.graphqlExpected output type.graphqlThe value to be serialized.graphqlSerialized value on success or . | null2 representation in the given serialization format.graphql1Expected type (variable type given in the query).graphqlVariable value being coerced.graphqlCoerced value on success,  otherwise.None #$]=graphqlQuery error types.graphql?Contains the operation to be executed along with its root type.graphqlSingle GraphQL field.graphqlGraphQL has 3 operation types: queries, mutations and subscribtions.graphqlSingle selection element.graphql*Represents fragments and inline fragments.graphqlRewrites the original syntax tree into an intermediate representation used for query execution. None#$bgraphql"Only exceptions that inherit from  a cought by the executor.graphqlEach event in the underlying Source Stream triggers execution of the subscription selection set. The results of the execution generate a Response Stream.graphqlThe server's response describes the result of executing the requested operation if successful, and describes any errors encountered during the request.graphqlGraphQL error.graphqlIf an error can be associated to a particular field in the GraphQL result, it must contain an entry with the key path that details the path of the response field which experienced the error. This allows clients to identify whether a null result is intentional or caused by a runtime error.graphql Field name.graphql&List index if a field returned a list.graphql(A wrapper to pass error messages around.graphqlExecutor context.graphql*Wraps a parse error into a list of errors.graphql$Adds an error to the list of errors.graphqlConstructs a response object containing only the error with the given message.graphql8Convenience function for just wrapping an error message.graphqlRuns the given query computation, but collects the errors into an error list, which is then sent back with the data.None#%c`None &dJgraphql Takes an  and a list of "s and applies each field to each 1. Resolves into a value containing the resolved (, or a null value and error information.None dq NonefCgraphqlThe substitution is applied to the document, and the resolvers are applied to the resulting fields. The operation name can be used if the document defines multiple root operations.Returns the result of the query against the schema wrapped in a data! field, or errors wrapped in an errors field.graphql Resolvers.graphqlOperation name.graphqlVariable substitution function.Noneggraphql$Monad transformer used by the rules.graphql assigns a function to each AST node that can be validated. If the validation fails, the function should return an error message, or  otherwise.graphqlValidation rule context.graphqlValidation error.None #$%&~+graphql)Default rules given in the specification.graphql=Definition must be OperationDefinition or FragmentDefinition.graphql9Subscription operations must have exactly one root field.graphqlGraphQL allows a short@hand form for defining query operations when only that one operation exists in the document.graphqlEach named operation definition must be unique within a document when referred to by its name.graphqlFragment definitions are referenced in fragment spreads by name. To avoid ambiguity, each fragment@s name must be unique within a document.Inline fragments are not considered fragment definitions, and are unaffected by this validation rule.graphqlNamed fragment spreads must refer to fragments defined within the document. It is a validation error if the target of a spread is not defined.graphqlFragments must be specified on types that exist in the schema. This applies for both named and inline fragments. If they are not defined in the schema, the query does not validate.graphqlFragments can only be declared on unions, interfaces, and objects. They are invalid on scalars. They can only be applied on non@leaf fields. This rule applies to both inline and named fragments.graphql1Defined fragments must be used within a document.graphqlThe graph of fragment spreads must not form any cycles including spreading itself. Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.graphqlFields and directives treat arguments as a mapping of argument name to value. More than one argument with the same name in an argument set is ambiguous and invalid.graphqlDirectives are used to describe some metadata or behavioral change on the definition they apply to. When more than one directive of the same name is used, the expected metadata or behavior becomes ambiguous, therefore only one of each directive is allowed per location.graphqlIf any operation defines more than one variable with the same name, it is ambiguous and invalid. It is invalid even if the type of the duplicate variable is the same.graphqlVariables can only be input types. Objects, unions and interfaces cannot be used as inputs.graphqlVariables are scoped on a per@operation basis. That means that any variable used within the context of an operation must be defined at the top level of that operation.graphqlAll variables defined by an operation must be used in that operation or a fragment transitively included by that operation. Unused variables cause a validation error.graphqlInput objects must not contain more than one field of the same name, otherwise an ambiguity would exist which includes an ignored portion of syntax.graphqlThe target field of a field selection must be defined on the scoped type of the selection set. There are no limitations on alias names.graphqlField selections on scalars or enums are never allowed, because they are the leaf nodes of any GraphQL query.graphqlEvery argument provided to a field or directive must be defined in the set of possible arguments of that field or directive.graphqlGraphQL servers define what directives they support. For each usage of a directive, the directive must be available on that server.graphqlEvery input field provided in an input object value must be defined in the set of possible fields of that input object@s expected type.graphqlGraphQL servers define what directives they support and where they support them. For each usage of a directive, the directive must be used in a location that the server has declared support for.graphqlArguments can be required. An argument is required if the argument type is non@null and does not have a default value. Otherwise, the argument is optional.graphqlInput object fields may be required. Much like a field may have required arguments, an input object may have required fields. An input field is required if it has a non@null type and does not have a default value. Otherwise, the input object field is optional.graphqlIf multiple field selections with the same response names are encountered during execution, the field and arguments to execute and the resulting value should be unambiguous. Therefore any two field selections which might both be encountered for the same object are only valid if they are equivalent.For simple hand@written GraphQL, this rule is obviously a clear developer error, however nested fragments can make this difficult to detect manually.graphqlFragments are declared on a type and will only apply when the runtime object type matches the type condition. They also are spread within the context of a parent type. A fragment spread is only valid if its type condition could ever apply within the parent type.graphqlVariable usages must be compatible with the arguments they are passed to.Validation failures occur when variables are used in the context of types that are complete mismatches, or if a nullable type in a variable is passed to a non@null argument type.graphqlLiteral values must be compatible with the type expected in the position they are found as per the coercion rules.The type expected in a position include the type defined by the argument a value is provided for, the type defined by an input object field a value is provided for, and the type of a variable definition a default value is provided for.None#$ graphqlValidates a document and returns a list of found errors. If the returned list is empty, the document is valid.##None #$ graphql"If the text parses correctly as a GraphQL. query the query is executed using the given .graphql"If the text parses correctly as a GraphQL query the substitution is applied to the query and the query is then executed using to the given .graphql Resolvers.graphqlText representing a GraphQL request document.graphql Response.graphql Resolvers.graphqlOperation name.graphqlVariable substitution function.graphqlText representing a GraphQL request document.graphql Response.None graphql,Asserts that a query resolves to some value.graphql5Asserts that the response doesn't contain any errors. !"#$%&'()*+,-.&/012345566778899:;<=>?@ABCDEFGHIJKLMNNOPQRRSO:TUGVWWXYZ[\]^_``aabcdefghijklmnopqrst"uv++ww,,--**xyz{|}~'()}TSWW##npqrst"uww\           \             * *                      WW\    p q r s " u                                               *xrqp"tuos*'()&graphql-1.0.0.0-2IzbiDNk1jPLfkyKV9BL8c&Language.GraphQL.AST.DirectiveLocationLanguage.GraphQL.AST.DocumentLanguage.GraphQL.AST.EncoderLanguage.GraphQL.AST.LexerLanguage.GraphQL.AST.Parser#Language.GraphQL.Execute.OrderedMapLanguage.GraphQL.TypeLanguage.GraphQL.Type.InLanguage.GraphQL.Type.OutLanguage.GraphQL.Type.SchemaLanguage.GraphQL.Execute.CoerceLanguage.GraphQL.ErrorLanguage.GraphQL.Execute$Language.GraphQL.Validate.ValidationLanguage.GraphQL.ValidateLanguage.GraphQLTest.Hspec.GraphQLLanguage.GraphQL.AST Language.GraphQL.Type.DefinitionLanguage.GraphQL.Type.Internal"Language.GraphQL.Execute.Transform!Language.GraphQL.Execute.Internal"Language.GraphQL.Execute.Execution"Language.GraphQL.Execute.SubscribeLanguage.GraphQL.Validate.RulesTypeSystemDirectiveLocationSchemaScalarObjectFieldDefinitionArgumentDefinition InterfaceUnionEnum EnumValue InputObjectInputFieldDefinitionExecutableDirectiveLocationQueryMutation SubscriptionFieldFragmentDefinitionFragmentSpreadInlineFragmentDirectiveLocation!$fShowExecutableDirectiveLocation!$fShowTypeSystemDirectiveLocation$fShowDirectiveLocation$fEqDirectiveLocation$fEqTypeSystemDirectiveLocation$fEqExecutableDirectiveLocationEnumValueDefinitionUnionMemberTypesInputValueDefinitionArgumentsDefinitionImplementsInterfaces TypeExtensionScalarTypeExtension#ObjectTypeFieldsDefinitionExtensionObjectTypeDirectivesExtension'ObjectTypeImplementsInterfacesExtension&InterfaceTypeFieldsDefinitionExtension InterfaceTypeDirectivesExtension"UnionTypeUnionMemberTypesExtensionUnionTypeDirectivesExtension%EnumTypeEnumValuesDefinitionExtensionEnumTypeDirectivesExtension-InputObjectTypeInputFieldsDefinitionExtension"InputObjectTypeDirectivesExtensionTypeDefinitionScalarTypeDefinitionObjectTypeDefinitionInterfaceTypeDefinitionUnionTypeDefinitionEnumTypeDefinitionInputObjectTypeDefinition DescriptionSchemaExtensionSchemaOperationExtensionSchemaDirectivesExtensionOperationTypeDefinitionTypeSystemExtensionTypeSystemDefinitionSchemaDefinitionDirectiveDefinition Directive NonNullTypeNonNullTypeNamedNonNullTypeList NamedTypeType TypeNamedTypeList TypeNonNullVariableDefinition ObjectField$sel:name:ObjectField$sel:value:ObjectField$sel:location:ObjectField ConstValueConstInt ConstFloat ConstString ConstBoolean ConstNull ConstEnum ConstList ConstObjectValueVariableIntFloatStringBooleanNullList TypeConditionArgument SelectionFieldSelectionFragmentSpreadSelectionInlineFragmentSelectionSelectionSetOpt SelectionSet OperationTypeOperationDefinitionExecutableDefinitionDefinitionOperationDefinitionFragment DefinitionDocumentNode$sel:node:Node$sel:location:NodeLocation$sel:line:Location$sel:column:LocationNameescape $fOrdLocation $fFunctorNode $fShowNode$fFunctorObjectField$fShowObjectField$fShowConstValue $fShowValue$fShowNonNullType $fShowType$fShowImplementsInterfaces$fEqImplementsInterfaces$fMonoidArgumentsDefinition$fSemigroupArgumentsDefinition$fShowUnionMemberTypes$fEqUnionMemberTypes$fEqDefinition$fShowDefinition$fEqTypeSystemDefinition$fShowTypeSystemDefinition$fEqTypeDefinition$fShowTypeDefinition$fEqTypeSystemExtension$fShowTypeSystemExtension$fEqTypeExtension$fShowTypeExtension$fEqEnumValueDefinition$fShowEnumValueDefinition$fEqFieldDefinition$fShowFieldDefinition$fEqArgumentsDefinition$fShowArgumentsDefinition$fEqInputValueDefinition$fShowInputValueDefinition$fEqDescription$fShowDescription$fEqSchemaExtension$fShowSchemaExtension$fEqOperationTypeDefinition$fShowOperationTypeDefinition$fEqExecutableDefinition$fShowExecutableDefinition$fEqOperationDefinition$fShowOperationDefinition$fEqFragmentDefinition$fShowFragmentDefinition $fEqField $fShowField $fEqSelection$fShowSelection$fEqInlineFragment$fShowInlineFragment$fEqFragmentSpread$fShowFragmentSpread $fEqDirective$fShowDirective$fEqVariableDefinition$fShowVariableDefinition$fEqNonNullType$fEqType $fEqArgument$fShowArgument $fEqValue$fEqConstValue$fEqObjectField$fEqOperationType$fShowOperationType$fEqNode $fEqLocation$fShowLocation Formatterprettyminifieddocument definition directivevaluetype'Parser spaceConsumercommentlexemesymbolbangdollaratampcolonequalsspreadpipeparensbracketsbracesstring blockStringintegerfloatname unicodeBOMextend OrderedMap singletonempty foldlWithKey' traverseMaybetoListkeyselemsinsertreplacesizelookup$fShowOrderedMap$fTraversableOrderedMap$fMonoidOrderedMap$fSemigroupOrderedMap$fFoldableOrderedMap$fFunctorOrderedMap$fEqOrderedMapEnumType ScalarType ArgumentsSubsbooleanintid selectionNamedScalarType NamedEnumTypeNamedInputObjectTypeListTypeNonNullScalarTypeNonNullEnumTypeNonNullInputObjectTypeNonNullListTypeInputObjectType InputField ListBaseTypeInputObjectBaseType EnumBaseTypeScalarBaseType isNonNullType$fShowInputObjectType$fEqInputObjectTypeResolver ValueResolverEventStreamResolverSourceEventStream SubscribeResolveContext argumentsvaluesNamedObjectTypeNamedInterfaceTypeNamedUnionTypeNonNullObjectTypeNonNullInterfaceTypeNonNullUnionType UnionType InterfaceType ObjectType UnionBaseTypeInterfaceBaseTypeObjectBaseTypeargument$fShowUnionType $fEqUnionType$fShowInterfaceType$fEqInterfaceType$fShowObjectType$fEqObjectType Directives descriptionquerymutation subscription directivestypesimplementationsschemaschemaWithTypesOutput Serialize serializenull VariableValuecoerceVariableValuematchFieldValuescoerceInputLiteral$fVariableValueValue$fIsStringOutput$fSerializeValue $fEqOutput $fShowOutputResolverExceptionResponseEventStreamResponse$sel:data':Response$sel:errors:ResponseError$sel:message:Error$sel:locations:Error$sel:path:ErrorPathSegmentIndex CollectErrsT Resolution$sel:errors:Resolution$sel:types:Resolution parseErroraddErr singleError addErrMsgrunCollectErrs$fExceptionResolverException$fShowResolverException $fEqResponse$fShowResponse $fEqError $fShowError$fEqPath $fShowPathexecuteRuleTRuleDefinitionRuleOperationDefinitionRuleFragmentDefinitionRule SelectionRule FragmentRuleFragmentSpreadRule FieldRule ArgumentsRuleDirectivesRule VariablesRule ValueRule Validationastmessage locationsspecifiedRulesexecutableDefinitionsRulesingleFieldSubscriptionsRuleloneAnonymousOperationRuleuniqueOperationNamesRuleuniqueFragmentNamesRulefragmentSpreadTargetDefinedRulefragmentSpreadTypeExistenceRulefragmentsOnCompositeTypesRulenoUnusedFragmentsRulenoFragmentCyclesRuleuniqueArgumentNamesRuleuniqueDirectiveNamesRuleuniqueVariableNamesRulevariablesAreInputTypesRulenoUndefinedVariablesRulenoUnusedVariablesRuleuniqueInputFieldNamesRulefieldsOnCorrectTypeRulescalarLeafsRuleknownArgumentNamesRuleknownDirectiveNamesRuleknownInputFieldNamesRuledirectivesInValidLocationsRuleprovidedRequiredArgumentsRuleprovidedRequiredInputFieldsRule overlappingFieldsCanBeMergedRulepossibleFragmentSpreadsRulevariablesInAllowedPositionRulevaluesOfCorrectTypeRulegraphql graphqlSubsshouldResolveTo shouldResolvebaseGHC.Base Semigroup GHC.MaybeJustNothing AbstractType CompositeTypeAbstractUnionTypeAbstractInterfaceTypeCompositeUnionTypeCompositeObjectTypeCompositeInterfaceTypedoesFragmentTypeApply instanceOflookupTypeConditionlookupInputTypelookupTypeFieldlookupCompositeFieldoutToComposite QueryError OperationFragmentInputOperationNotFoundOperationNameRequired CoercionError EmptyDocumentUnsupportedRootOperationSelectionFragmentSelectionFieldaddErrorexecuteSelectionSet collectFieldscoerceArgumentValues subscribe