#      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                        Safegraphql8Where directives can appear in a type system definition. graphqlFWhere 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"#Xdo6&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 #.<They can also be used as field definitions in an input type. (input Point2D { x: Float y: Float } The input type Point2D- contains two value definitions: "x" and "y".#graphql#A list of values passed to a field. Gtype Person { name: String picture(width: Int, height: Int): Url } PersonN has two fields, "name" and "picture". "name" doesn't have any arguments, so #_ contains an empty list. "picture" contains definitions for 2 arguments: "width" and "height".%graphql'Definition of a single field in a type. Gtype Person { name: String picture(width: Int, height: Int): Url } R"name" and "picture", including their arguments and types, are field definitions.'graphqlBDefines a list of interfaces implemented by the given object type. Gtype Business implements NamedEntity & ValuedEntity { name: String } Here the object type Business implements two interfaces:  NamedEntity and  ValuedEntity.)graphql-Extensions for custom, already defined types.6graphql5Type definitions describe various user-defined types.=graphqlGraphQL has built-in capability to document service APIs. Documentation is a GraphQL string that precedes a particular definition and contains Markdown. Any GraphQL definition can be documented this way. /""" Supported languages. """ enum Language { English EN Russian RU } ?graphqlGExtension of the schema definition by further operations or directives.BgraphqlRoot operation type definition.kDefining root operation types is not required since they have defaults. So the default query root type is Query), and the default mutation root type is Mutationt. But these defaults can be changed for a specific schema. In the following code the query root type is changed to MyQueryRootType!, and the mutation root type to MyMutationRootType: Cschema { query: MyQueryRootType mutation: MyMutationRootType } DgraphqlZExtension for a type system definition. Only schema and type definitions can be extended.Ggraphql7Type system can define a schema, a type or a directive. %schema { query: Query } directive :example on FIELD_DEFINITION type Query { field: String  example } sThis example defines a custom directive "@example", which is applied to a field definition of the type definition QueryD. On the top the schema is defined by taking advantage of the type Query.Kgraphql Directive.Directives begin with "@", can accept arguments, and can be applied to the most GraphQL elements, providing additional information.Mgraphql@Helper type to represent Non-Null types and lists of such types.PgraphqlRepresents type names.QgraphqlType representation.UgraphqlVariable definition./Each operation can include a list of variables: query (protagonist: String =  Zarathustra-) { getAuthor(protagonist: $protagonist) } (This query defines an optional variable  protagonist of type String, its default value is  ZarathustraT. If no default value is defined and no value is provided, a variable can still be null if its type is nullable.lVariables are usually passed along with the query, but not in the query itself. They make queries reusable.WgraphqlKey-value pair. A list of W#s represents a GraphQL object type.\graphqlConstant input value.egraphql"Input value (literal or variable).ographqlType condition.pgraphqlFragment definition.rgraphqlSingle argument. !{ user(id: 4) { name } } AHere "id" is an argument for the field "user" and its value is 4.tgraphqllA fragment spread refers to a fragment defined outside the operation and is expanded at the execution time. X{ user { ...userFragment } } fragment userFragment on UserType { id name } vgraphqlYInline fragments don't have any name and the type condition ("on UserType") is optional. ={ user { ... on UserType { id name } } xgraphqlThe only required property of a field is its name. Optionally it can also have an alias, arguments, directives and a list of subfields.MIn the following query "user" is a field with two subfields, "id" and "name": !{ user { id name } } zgraphqlCSelection is a single entry in a selection set. It can be a single x, t or an v.~graphqlField selection.graphql="Top-level" selection, selection on an operation or fragment.graphqlGraphQL has 3 operation types:query - a read-only fetch.1mutation - a write operation followed by a fetch.Tsubscription - a long-lived request that fetches data in response to source events.graphqlOperation definition.graphqlFTop-level definition of a document, either an operation or a fragment.graphql>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.{ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGIHJKLMNOPQRSTUVWXZ[Y\]^_`abcdeihglnkmfjopqrstuvwxyz{|}~{rs#$\]^_`abcd=>KLxy%&pqtu'(vw!"PMNOWXZ[YBC?@Az{|}~QRSTo6789:;<)*+,-./012345GIHJDEF eihglnkmfjUVSafe"#X_{ graphql[Instructs 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.graphql3Converts a 'Full.OperationDefinition into a string.graphqlConverts Field 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.SafeXgraphql7Standard parser. Accepts the type of the parsed token.graphqlOParser 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"#X_graphql!Parser for the GraphQL documents.Safe| !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGIHJKLMNOPQRSTUVWXZ[Y\]^_`abcdeihglnkmfjopqrstuvwxyz{|}~SafegraphqlDirective processing status.graphql0Skip the selection and stop directive processinggraphql/The directive was processed, try other handlersgraphql.Directive handler mismatch, try other handlersgraphql 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.VThe leaf values of any request and input values to arguments are Scalars (or Enums) .graphqlArgument list.graphqlnContains 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 Intf scalar type represents non-fractional signed whole numeric values. Int can represent values between -2^{31} and  2^{31 - 1}.graphqlThe FloatT 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%g graphqlField argument definitions.graphqlField argument definition.graphqlDThese 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.eAn 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%Xg>-graphql-' associates some function(s) with each D. . resolves a D into a . / resolves additionally a D into a 01 if it is the field of a root subscription type.!The resolvers aren't part of the D_ itself because not all fields have resolvers (interface fields don't have an implementation).0graphqlA source stream represents the sequence of events, each of which will trigger a GraphQL execution corresponding to that event.1graphqlqMonad transformer stack used by the resolvers for determining the resolved event stream of a subscription field.2graphql]Monad transformer stack used by the resolvers for determining the resolved value of a field.3graphql?Resolution context holds resolver arguments and the root value.7graphql@These 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).DgraphqlOutput object field definition.FgraphqlUnion Type Definition.wWhen a field can return one of a heterogeneous set of types, a Union type is used to describe what types are possible.HgraphqlInterface 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.JgraphqlObject 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.LgraphqlMatches either = or C.MgraphqlMatches either < or B.NgraphqlMatches either ; or A.OgraphqlMatches either : or @.PgraphqlMatches either 9 or ?.QgraphqlMatches either 8 or >.Rgraphql8Checks whether the given output type is a non-null type.Sgraphql^Retrieves 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).Egraphql Description.graphql Field type.graphql Arguments.'-./0123456789=>?C:;<@ABDEFGHIJKLMNOPQRS'3456DEHIJK21-./0789=>?C:;<@ABFGSRPNLOQMNoneX_2 graphql?These types may describe the parent context of a selection set.graphql?These types may describe the parent context of a selection set.XgraphqlA 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.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.YgraphqlDirective definitions.ZgraphqlDirective definition.\graphql-These are all of the possible kinds of types.cgraphqlSchema query type.dgraphqlSchema mutation type.egraphqlSchema subscription type.fgraphqlSchema directive definitions.ggraphqlTypes referenced by the schema.XYZ[\`a_b^]cdefg NoneXLhgraphqlSchema constructor.graphql4Traverses the schema and finds all referenced types.hgraphql Query type.graphqlMutation type.graphqlSubscription type.graphqlDirective definitions.graphqlSchema.XYZ[\`a_b^]cdefghhXYZ[\`a_b^]cdefgNone 3     "#$%-./0123456DEFGHIJKSXh3$%"#3456DEHIJK2-./01FGS     Xh None%Xigraphql&Intermediate type used to serialize a GraphQL value.4The serialization is done during the execution, and i' contains already serialized data (in o and pN) as well as the new layer that has to be serialized in the current step. So i/ is parameterized by the serialization format.qgraphqlq describes how a GraphQL value should be serialized.rgraphql 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.FIf the value cannot be serialized without losing information, return   it will cause a field error.tgraphqlSince variables are passed separately from the query, in an independent format, they should be first coerced to the internal representation used by this implementation.ugraphqlOnly 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 u 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 IDL 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, R should be returned, the coercion will fail then and the query won't be executed.vgraphqlwLooks 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 S if the Input Type is a Non-Nullable type, or returns the unchanged, original map.wgraphql_Coerces operation arguments according to the input coercion rules for the corresponding types.rgraphqlExpected output type.graphqlThe value to be serialized.graphqlSerialized value on success or . | null2 representation in the given serialization format.ugraphql1Expected type (variable type given in the query).graphqlVariable value being coerced.graphqlCoerced value on success,  otherwise.ilkjnpomqsrtuvwilkjnpomqsrtuwvNone"#PX_&1 graphqlQuery error types.graphql?Contains the operation to be executed along with its root type.graphqlSingle GraphQL field.graphqlDGraphQL has 3 operation types: queries, mutations and subscribtions.3Currently only queries and mutations are supported.graphqlSingle selection element.graphql*Represents fragments and inline fragments.graphql*Associates a fragment name with a list of s.graphql`Rewrites the original syntax tree into an intermediate representation used for query execution.graphql+Extract fragment definitions into a single .      None"#EXd:}graphql"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.graphql$If 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.graphqlOConstructs a response object containing only the error with the given message.graphql8Convenience function for just wrapping an error message.graphqluRuns the given query computation, but collects the errors into an error list, which is then sent back with the data.}~}~None%X>J graphql Takes an J 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. NoneX> NoneEgraphqlThe 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.ilkjnpomqsrtuvw NoneIgraphql$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"#%X_<graphql)Default rules given in the specification.graphql=Definition must be OperationDefinition or FragmentDefinition.graphql9Subscription operations must have exactly one root field.graphqltGraphQL allows a short hand form for defining query operations when only that one operation exists in the document.graphql_Each 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.fInline 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.graphql\Variables 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.graphqlnField selections on scalars or enums are never allowed, because they are the leaf nodes of any GraphQL query.graphql}Every 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.None"#X_graphqloValidates a document and returns a list of found errors. If the returned list is empty, the document is valid.None"#Ygraphql"If the text parses correctly as a GraphQL. query the query is executed using the given X.graphql"If the text parses correctly as a GraphQLd query the substitution is applied to the query and the query is then executed using to the given X.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.NoneXgraphql,Asserts that a query resolves to some value.graphql5Asserts that the response doesn't contain any errors. !"#$%&'()*+,$-./012334455667789:;<=>?@ABCDEFGHIJKLLMNOPPQM8RSETUUVWXYZ[\]^^__`abcdefghijklmnopqr st))uu**++((vwxyz{|%&'}{}~~RQUU!!lnopqr suuZ      Z((UUZ !"# $ % n o p q  s  & ' ( ) * + , - . / 0 1 2 2 3 4 4 5 6 7 7 8 9 : ; < = > ? ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ] ^ $ 7 7 _ ` K Labcdefghijklmnopqrstuvwxyz{|}~ (vpon rsmq(%&'graphql-0.11.0.0-inplace&Language.GraphQL.AST.DirectiveLocationLanguage.GraphQL.AST.DocumentLanguage.GraphQL.AST.EncoderLanguage.GraphQL.AST.LexerLanguage.GraphQL.AST.ParserLanguage.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.Execution"Language.GraphQL.Execute.SubscribeLanguage.GraphQL.Validate.RulesTypeSystemDirectiveLocationSchemaScalarObjectFieldDefinitionArgumentDefinition InterfaceUnionEnum EnumValue InputObjectInputFieldDefinitionExecutableDirectiveLocationQueryMutation SubscriptionFieldFragmentDefinitionFragmentSpreadInlineFragmentDirectiveLocation!$fShowExecutableDirectiveLocation!$fShowTypeSystemDirectiveLocation$fShowDirectiveLocation$fEqExecutableDirectiveLocation$fEqTypeSystemDirectiveLocation$fEqDirectiveLocationEnumValueDefinitionUnionMemberTypesInputValueDefinitionArgumentsDefinitionImplementsInterfaces 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:LocationName $fOrdLocation $fFunctorNode$fShowImplementsInterfaces$fEqImplementsInterfaces$fMonoidArgumentsDefinition$fSemigroupArgumentsDefinition$fShowUnionMemberTypes$fEqUnionMemberTypes $fEqLocation$fShowLocation$fEqNode $fShowNode$fEqOperationType$fShowOperationType$fEqObjectField$fShowObjectField$fEqConstValue$fShowConstValue $fEqValue $fShowValue $fEqArgument$fShowArgument$fEqNonNullType$fShowNonNullType$fEqType $fShowType$fEqVariableDefinition$fShowVariableDefinition $fEqDirective$fShowDirective$fEqFragmentSpread$fShowFragmentSpread $fEqField $fShowField $fEqSelection$fShowSelection$fEqInlineFragment$fShowInlineFragment$fEqFragmentDefinition$fShowFragmentDefinition$fEqOperationDefinition$fShowOperationDefinition$fEqExecutableDefinition$fShowExecutableDefinition$fEqOperationTypeDefinition$fShowOperationTypeDefinition$fEqSchemaExtension$fShowSchemaExtension$fEqDescription$fShowDescription$fEqInputValueDefinition$fShowInputValueDefinition$fEqArgumentsDefinition$fShowArgumentsDefinition$fEqFieldDefinition$fShowFieldDefinition$fEqEnumValueDefinition$fShowEnumValueDefinition$fEqTypeExtension$fShowTypeExtension$fEqTypeSystemExtension$fShowTypeSystemExtension$fEqTypeDefinition$fShowTypeDefinition$fEqTypeSystemDefinition$fShowTypeSystemDefinition$fEqDefinition$fShowDefinition Formatterprettyminifieddocument definition directivevaluetype'Parser spaceConsumercommentlexemesymbolbangdollaratampcolonequalsspreadpipeparensbracketsbracesstring blockStringintegerfloatname unicodeBOMextendEnumType ScalarType ArgumentsSubsbooleanintid selectionNamedScalarType NamedEnumTypeNamedInputObjectTypeListTypeNonNullScalarTypeNonNullEnumTypeNonNullInputObjectTypeNonNullListTypeInputObjectType InputField ListBaseTypeInputObjectBaseType EnumBaseTypeScalarBaseType isNonNullType$fEqInputObjectTypeResolver ValueResolverEventStreamResolverSourceEventStream SubscribeResolveContext argumentsvaluesNamedObjectTypeNamedInterfaceTypeNamedUnionTypeNonNullObjectTypeNonNullInterfaceTypeNonNullUnionType UnionType InterfaceType ObjectType UnionBaseTypeInterfaceBaseTypeObjectBaseTypeargument $fEqUnionType$fEqInterfaceType$fEqObjectType Directivesquerymutation subscription directivestypesschemaOutput 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$fEqPath $fShowPath $fEqError $fShowError $fEqResponse$fShowResponseexecuteRuleTRuleDefinitionRuleOperationDefinitionRuleFragmentDefinitionRule SelectionRule FragmentRuleFragmentSpreadRule FieldRule ArgumentsRuleDirectivesRule VariablesRule ValueRule Validationastmessage locationsspecifiedRulesexecutableDefinitionsRulesingleFieldSubscriptionsRuleloneAnonymousOperationRuleuniqueOperationNamesRuleuniqueFragmentNamesRulefragmentSpreadTargetDefinedRulefragmentSpreadTypeExistenceRulefragmentsOnCompositeTypesRulenoUnusedFragmentsRulenoFragmentCyclesRuleuniqueArgumentNamesRuleuniqueDirectiveNamesRuleuniqueVariableNamesRulevariablesAreInputTypesRulenoUndefinedVariablesRulenoUnusedVariablesRuleuniqueInputFieldNamesRulefieldsOnCorrectTypeRulescalarLeafsRuleknownArgumentNamesRuleknownDirectiveNamesRuleknownInputFieldNamesRuledirectivesInValidLocationsRuleprovidedRequiredArgumentsRuleprovidedRequiredInputFieldsRulegraphql graphqlSubsshouldResolveTo shouldResolveoperationDefinitionfieldStatusSkipIncludeContinuebase GHC.MaybeNothing AbstractType CompositeTypeAbstractUnionTypeAbstractInterfaceTypeCompositeUnionTypeCompositeObjectTypeCompositeInterfaceTypedoesFragmentTypeApply instanceOflookupTypeConditionlookupInputTypelookupTypeFieldcollectReferencedTypes QueryError OperationFragment ReplacementcollectFragments^unordered-containers-0.2.13.0-759a951705318ca918bbc48a79364bd6e41b7fd878639eeab699bda3d8311888Data.HashMap.InternalHashMapInputOperationNotFoundOperationNameRequired CoercionErrorTransformationError EmptyDocumentUnsupportedRootOperationSelectionFragmentSelectionField queryErrorexecuteSelectionSet collectFieldscoerceArgumentValues subscribe