@0no-co/graphql.web 0.1.2 → 0.1.4

package/README.md

@@ -0,0 +1,60 @@
+<div align="center">
+  <h2>@0no-co/graphql.web</h2>
+  <strong>The spec-compliant minimum of client-side GraphQL.</strong>
+  <br />
+  <br />
+  <a href="https://github.com/0no-co/graphql.web/actions/workflows/release.yml">
+    <img alt="CI Status" src="https://github.com/0no-co/graphql.web/actions/workflows/release.yml/badge.svg?branch=main" />
+  </a>
+  <a href="https://npmjs.com/package/@0no-co/graphql.web">
+    <img alt="Bundlesize" src="https://deno.bundlejs.com/?q=@0no-co/graphql.web&badge" />
+  </a>
+  <a href="https://urql.dev/discord">
+    <img alt="Discord" src="https://img.shields.io/discord/1082378892523864074?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+  <br />
+  <br />
+</div>
+
+`@0no-co/graphql.web` is an **experimental** library, aiming to provide an
+absolute minimum of features and exports of `graphql` utilities that typical
+GraphQL web apps or GraphQL clients need.
+
+While its goal isn’t to be an exact match to [the GraphQL.js
+API](https://graphql.org/graphql-js/graphql/) it aims to provide API- and
+type-compatible where possible and necessary. However, its goal is to provide
+the smallest implementation for common GraphQL utilities that are still either
+spec-compliant or compatible with GraphQL.js’ implementation.
+
+> **Note:** While this library can be used as a drop-in replacement for
+> `graphql` in _some cases_, the [`graphql-web-lite`
+> project](https://github.com/0no-co/graphql-web-lite) is maintained to be
+> a full shim/alias for the `graphql` package.
+
+### API
+
+Currently, only a select few exports are provided — namely, the ones listed here
+are used in `@urql/core`, and we expect them to be common in all client-side
+GraphQL applications.
+
+| Export | Description | Links |
+| --- | ----------- | -------- |
+| `parse` | A tiny (but compliant) GraphQL query language parser. | [Source](./src/parser.ts) |
+| `print` | A (compliant) GraphQL query language printer. | [Source](./src/printer.ts) |
+| `visit` | A recursive reimplementation of GraphQL.js’ visitor. | [Source](./src/printer.ts) |
+| `Kind` | The GraphQL.js’ `Kind` enum, containing supported `ASTNode` kinds. | [Source](./src/kind.ts) |
+| `GraphQLError` | `GraphQLError` stripped of source/location debugging. | [Source](./src/kind.ts) |
+| `valueFromASTUntyped` | Coerces AST values into JS values. | [Source](./src/values.ts) |
+
+The stated goals of any reimplementation are:
+1. Not to implement any execution or type system parts of the GraphQL
+   specification.
+2. To adhere to GraphQL.js’ types and APIs as much as possible.
+3. Not to implement or expose any rarely used APIs or properties of the
+   GraphQL.js library.
+4. To provide a minimal and maintainable subset of GraphQL.js utilities.
+
+Therefore, while we can foresee implementing APIs that are entirely separate and
+unrelated to the GraphQL.js library in the future, for now the stated goals are
+designed to allow this library to be used by GraphQL clients, like
+[`@urql/core`](https://github.com/urql-graphql/urql).

package/dist/graphql.web.d.ts

@@ -1,60 +1,251 @@
-declare enum Kind {
-    /** Name */
-    NAME = "Name",
-    /** Document */
-    DOCUMENT = "Document",
-    OPERATION_DEFINITION = "OperationDefinition",
-    VARIABLE_DEFINITION = "VariableDefinition",
-    SELECTION_SET = "SelectionSet",
-    FIELD = "Field",
-    ARGUMENT = "Argument",
-    /** Fragments */
-    FRAGMENT_SPREAD = "FragmentSpread",
-    INLINE_FRAGMENT = "InlineFragment",
-    FRAGMENT_DEFINITION = "FragmentDefinition",
-    /** Values */
-    VARIABLE = "Variable",
-    INT = "IntValue",
-    FLOAT = "FloatValue",
-    STRING = "StringValue",
-    BOOLEAN = "BooleanValue",
-    NULL = "NullValue",
-    ENUM = "EnumValue",
-    LIST = "ListValue",
-    OBJECT = "ObjectValue",
-    OBJECT_FIELD = "ObjectField",
-    /** Directives */
-    DIRECTIVE = "Directive",
-    /** Types */
-    NAMED_TYPE = "NamedType",
-    LIST_TYPE = "ListType",
-    NON_NULL_TYPE = "NonNullType"
-}
-
-interface Location {
-    readonly start: number;
-    readonly end: number;
-    readonly source: Source;
+type Maybe<T> = T | undefined | null;
+interface Extensions {
+    [extension: string]: unknown;
 }
-interface Source {
+type Source = any | {
     body: string;
     name: string;
     locationOffset: {
         line: number;
         column: number;
     };
+};
+type Location = any | {
+    start: number;
+    end: number;
+    source: Source;
+};
+
+declare enum Kind {
+  /** Name */
+  NAME = 'Name',
+  /** Document */
+  DOCUMENT = 'Document',
+  OPERATION_DEFINITION = 'OperationDefinition',
+  VARIABLE_DEFINITION = 'VariableDefinition',
+  SELECTION_SET = 'SelectionSet',
+  FIELD = 'Field',
+  ARGUMENT = 'Argument',
+  /** Fragments */
+  FRAGMENT_SPREAD = 'FragmentSpread',
+  INLINE_FRAGMENT = 'InlineFragment',
+  FRAGMENT_DEFINITION = 'FragmentDefinition',
+  /** Values */
+  VARIABLE = 'Variable',
+  INT = 'IntValue',
+  FLOAT = 'FloatValue',
+  STRING = 'StringValue',
+  BOOLEAN = 'BooleanValue',
+  NULL = 'NullValue',
+  ENUM = 'EnumValue',
+  LIST = 'ListValue',
+  OBJECT = 'ObjectValue',
+  OBJECT_FIELD = 'ObjectField',
+  /** Directives */
+  DIRECTIVE = 'Directive',
+  /** Types */
+  NAMED_TYPE = 'NamedType',
+  LIST_TYPE = 'ListType',
+  NON_NULL_TYPE = 'NonNullType',
+  /** Type System Definitions */
+  SCHEMA_DEFINITION = 'SchemaDefinition',
+  OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition',
+  /** Type Definitions */
+  SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition',
+  OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition',
+  FIELD_DEFINITION = 'FieldDefinition',
+  INPUT_VALUE_DEFINITION = 'InputValueDefinition',
+  INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition',
+  UNION_TYPE_DEFINITION = 'UnionTypeDefinition',
+  ENUM_TYPE_DEFINITION = 'EnumTypeDefinition',
+  ENUM_VALUE_DEFINITION = 'EnumValueDefinition',
+  INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition',
+  /** Directive Definitions */
+  DIRECTIVE_DEFINITION = 'DirectiveDefinition',
+  /** Type System Extensions */
+  SCHEMA_EXTENSION = 'SchemaExtension',
+  /** Type Extensions */
+  SCALAR_TYPE_EXTENSION = 'ScalarTypeExtension',
+  OBJECT_TYPE_EXTENSION = 'ObjectTypeExtension',
+  INTERFACE_TYPE_EXTENSION = 'InterfaceTypeExtension',
+  UNION_TYPE_EXTENSION = 'UnionTypeExtension',
+  ENUM_TYPE_EXTENSION = 'EnumTypeExtension',
+  INPUT_OBJECT_TYPE_EXTENSION = 'InputObjectTypeExtension',
+}
+
+declare enum OperationTypeNode {
+  QUERY = 'query',
+  MUTATION = 'mutation',
+  SUBSCRIPTION = 'subscription',
+}
+
+/** Type System Definition */
+declare type TypeSystemDefinitionNode = SchemaDefinitionNode | TypeDefinitionNode | DirectiveDefinitionNode;
+interface SchemaDefinitionNode {
+    readonly kind: Kind.SCHEMA_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
+}
+interface OperationTypeDefinitionNode {
+    readonly kind: Kind.OPERATION_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly operation: OperationTypeNode;
+    readonly type: NamedTypeNode;
+}
+/** Type Definition */
+declare type TypeDefinitionNode = ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | InputObjectTypeDefinitionNode;
+interface ScalarTypeDefinitionNode {
+    readonly kind: Kind.SCALAR_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface ObjectTypeDefinitionNode {
+    readonly kind: Kind.OBJECT_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface FieldDefinitionNode {
+    readonly kind: Kind.FIELD_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
+    readonly type: TypeNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InputValueDefinitionNode {
+    readonly kind: Kind.INPUT_VALUE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly type: TypeNode;
+    readonly defaultValue?: ConstValueNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InterfaceTypeDefinitionNode {
+    readonly kind: Kind.INTERFACE_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface UnionTypeDefinitionNode {
+    readonly kind: Kind.UNION_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly types?: ReadonlyArray<NamedTypeNode>;
+}
+interface EnumTypeDefinitionNode {
+    readonly kind: Kind.ENUM_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
+}
+interface EnumValueDefinitionNode {
+    readonly kind: Kind.ENUM_VALUE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InputObjectTypeDefinitionNode {
+    readonly kind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
+}
+/** Directive Definitions */
+interface DirectiveDefinitionNode {
+    readonly kind: Kind.DIRECTIVE_DEFINITION;
+    readonly loc?: Location;
+    readonly description?: StringValueNode;
+    readonly name: NameNode;
+    readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
+    readonly repeatable: boolean;
+    readonly locations: ReadonlyArray<NameNode>;
+}
+/** Type System Extensions */
+declare type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
+interface SchemaExtensionNode {
+    readonly kind: Kind.SCHEMA_EXTENSION;
+    readonly loc?: Location;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
+}
+/** Type Extensions */
+declare type TypeExtensionNode = ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode;
+interface ScalarTypeExtensionNode {
+    readonly kind: Kind.SCALAR_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface ObjectTypeExtensionNode {
+    readonly kind: Kind.OBJECT_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface InterfaceTypeExtensionNode {
+    readonly kind: Kind.INTERFACE_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<FieldDefinitionNode>;
 }
-declare type ASTNode = NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentSpreadNode | InlineFragmentNode | FragmentDefinitionNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode | ObjectFieldNode | DirectiveNode | NamedTypeNode | ListTypeNode | NonNullTypeNode;
+interface UnionTypeExtensionNode {
+    readonly kind: Kind.UNION_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly types?: ReadonlyArray<NamedTypeNode>;
+}
+interface EnumTypeExtensionNode {
+    readonly kind: Kind.ENUM_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
+}
+interface InputObjectTypeExtensionNode {
+    readonly kind: Kind.INPUT_OBJECT_TYPE_EXTENSION;
+    readonly loc?: Location;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
+}
+
+type ASTNode = NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentSpreadNode | InlineFragmentNode | FragmentDefinitionNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode | ObjectFieldNode | DirectiveNode | NamedTypeNode | ListTypeNode | NonNullTypeNode | SchemaDefinitionNode | OperationTypeDefinitionNode | ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | FieldDefinitionNode | InputValueDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | EnumValueDefinitionNode | InputObjectTypeDefinitionNode | DirectiveDefinitionNode | SchemaExtensionNode | ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode;
 interface NameNode {
     readonly kind: Kind.NAME;
     readonly value: string;
+    readonly loc?: Location;
 }
 interface DocumentNode {
     readonly kind: Kind.DOCUMENT;
-    readonly definitions: ReadonlyArray<ExecutableDefinitionNode>;
+    readonly definitions: ReadonlyArray<DefinitionNode>;
     readonly loc?: Location;
 }
-type DefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
+type DefinitionNode = ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode;
 type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
 interface OperationDefinitionNode {
     readonly kind: Kind.OPERATION_DEFINITION;
@@ -63,11 +254,7 @@ interface OperationDefinitionNode {
     readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
-}
-declare const enum OperationTypeNode {
-    QUERY = "query",
-    MUTATION = "mutation",
-    SUBSCRIPTION = "subscription"
+    readonly loc?: Location;
 }
 interface VariableDefinitionNode {
     readonly kind: Kind.VARIABLE_DEFINITION;
@@ -75,14 +262,17 @@ interface VariableDefinitionNode {
     readonly type: TypeNode;
     readonly defaultValue?: ConstValueNode;
     readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+    readonly loc?: Location;
 }
 interface VariableNode {
     readonly kind: Kind.VARIABLE;
     readonly name: NameNode;
+    readonly loc?: Location;
 }
 interface SelectionSetNode {
-    kind: Kind.SELECTION_SET;
-    selections: ReadonlyArray<SelectionNode>;
+    readonly kind: Kind.SELECTION_SET;
+    readonly selections: ReadonlyArray<SelectionNode>;
+    readonly loc?: Location;
 }
 declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
 interface FieldNode {
@@ -92,27 +282,32 @@ interface FieldNode {
     readonly arguments?: ReadonlyArray<ArgumentNode>;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet?: SelectionSetNode;
+    readonly loc?: Location;
 }
 interface ArgumentNode {
     readonly kind: Kind.ARGUMENT;
     readonly name: NameNode;
     readonly value: ValueNode;
+    readonly loc?: Location;
 }
 interface ConstArgumentNode {
     readonly kind: Kind.ARGUMENT;
     readonly name: NameNode;
     readonly value: ConstValueNode;
+    readonly loc?: Location;
 }
 interface FragmentSpreadNode {
     readonly kind: Kind.FRAGMENT_SPREAD;
     readonly name: NameNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly loc?: Location;
 }
 interface InlineFragmentNode {
     readonly kind: Kind.INLINE_FRAGMENT;
     readonly typeCondition?: NamedTypeNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
+    readonly loc?: Location;
 }
 interface FragmentDefinitionNode {
     readonly kind: Kind.FRAGMENT_DEFINITION;
@@ -120,105 +315,122 @@ interface FragmentDefinitionNode {
     readonly typeCondition: NamedTypeNode;
     readonly directives?: ReadonlyArray<DirectiveNode>;
     readonly selectionSet: SelectionSetNode;
+    readonly loc?: Location;
 }
 type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
 type ConstValueNode = IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode;
 interface IntValueNode {
     readonly kind: Kind.INT;
     readonly value: string;
+    readonly loc?: Location;
 }
 interface FloatValueNode {
     readonly kind: Kind.FLOAT;
     readonly value: string;
+    readonly loc?: Location;
 }
 interface StringValueNode {
     readonly kind: Kind.STRING;
     readonly value: string;
     readonly block?: boolean;
+    readonly loc?: Location;
 }
 interface BooleanValueNode {
     readonly kind: Kind.BOOLEAN;
     readonly value: boolean;
+    readonly loc?: Location;
 }
 interface NullValueNode {
     readonly kind: Kind.NULL;
+    readonly loc?: Location;
 }
 interface EnumValueNode {
     readonly kind: Kind.ENUM;
     readonly value: string;
+    readonly loc?: Location;
 }
 interface ListValueNode {
     readonly kind: Kind.LIST;
     readonly values: ReadonlyArray<ValueNode>;
+    readonly loc?: Location;
 }
 interface ConstListValueNode {
     readonly kind: Kind.LIST;
     readonly values: ReadonlyArray<ConstValueNode>;
+    readonly loc?: Location;
 }
 interface ObjectValueNode {
     readonly kind: Kind.OBJECT;
     readonly fields: ReadonlyArray<ObjectFieldNode>;
+    readonly loc?: Location;
 }
 interface ConstObjectValueNode {
     readonly kind: Kind.OBJECT;
     readonly fields: ReadonlyArray<ConstObjectFieldNode>;
+    readonly loc?: Location;
 }
 interface ObjectFieldNode {
     readonly kind: Kind.OBJECT_FIELD;
     readonly name: NameNode;
     readonly value: ValueNode;
+    readonly loc?: Location;
 }
 interface ConstObjectFieldNode {
     readonly kind: Kind.OBJECT_FIELD;
     readonly name: NameNode;
     readonly value: ConstValueNode;
+    readonly loc?: Location;
 }
 interface DirectiveNode {
     readonly kind: Kind.DIRECTIVE;
     readonly name: NameNode;
     readonly arguments?: ReadonlyArray<ArgumentNode>;
+    readonly loc?: Location;
 }
 interface ConstDirectiveNode {
     readonly kind: Kind.DIRECTIVE;
     readonly name: NameNode;
     readonly arguments?: ReadonlyArray<ConstArgumentNode>;
+    readonly loc?: Location;
 }
 declare type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
 interface NamedTypeNode {
     readonly kind: Kind.NAMED_TYPE;
     readonly name: NameNode;
+    readonly loc?: Location;
 }
 interface ListTypeNode {
     readonly kind: Kind.LIST_TYPE;
     readonly type: TypeNode;
+    readonly loc?: Location;
 }
 interface NonNullTypeNode {
     readonly kind: Kind.NON_NULL_TYPE;
     readonly type: NamedTypeNode | ListTypeNode;
-}
-
-type Maybe<T> = T | undefined | null;
-interface Extensions {
-    [extension: string]: unknown;
+    readonly loc?: Location;
 }
 
 declare class GraphQLError extends Error {
-    readonly locations: undefined;
+    readonly locations: ReadonlyArray<any> | undefined;
     readonly path: ReadonlyArray<string | number> | undefined;
-    readonly nodes: ReadonlyArray<ASTNode> | undefined;
+    readonly nodes: ReadonlyArray<any> | undefined;
     readonly source: Source | undefined;
     readonly positions: ReadonlyArray<number> | undefined;
     readonly originalError: Error | undefined;
     readonly extensions: Extensions;
     constructor(message: string, nodes?: ReadonlyArray<ASTNode> | ASTNode | null, source?: Maybe<Source>, positions?: Maybe<ReadonlyArray<number>>, path?: Maybe<ReadonlyArray<string | number>>, originalError?: Maybe<Error>, extensions?: Maybe<Extensions>);
-    toJSON(): this;
+    toJSON(): any;
     toString(): string;
+    get [Symbol.toStringTag](): string;
 }
 
 declare function blockString(string: string): string;
-declare function parse(string: string): DocumentNode;
-declare function parseValue(string: string): ValueNode | undefined;
-declare function parseType(string: string): TypeNode | undefined;
+type ParseOptions = {
+    [option: string]: any;
+};
+declare function parse(string: string | Source, _options?: ParseOptions | undefined): DocumentNode;
+declare function parseValue(string: string | Source, _options?: ParseOptions | undefined): ValueNode;
+declare function parseType(string: string | Source, _options?: ParseOptions | undefined): TypeNode;
 
 declare const BREAK: {};
 declare function visit<N extends ASTNode>(root: N, visitor: ASTVisitor): N;
@@ -247,4 +459,7 @@ declare function printString(string: string): string;
 declare function printBlockString(string: string): string;
 declare function print(node: ASTNode): string;
 
-export { ASTNode, ASTReducer, ASTVisitFn, ASTVisitor, ArgumentNode, BREAK, BooleanValueNode, ConstArgumentNode, ConstDirectiveNode, ConstListValueNode, ConstObjectFieldNode, ConstObjectValueNode, ConstValueNode, DefinitionNode, DirectiveNode, DocumentNode, EnumValueNode, ExecutableDefinitionNode, FieldNode, FloatValueNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, IntValueNode, Kind, ListTypeNode, ListValueNode, Location, NameNode, NamedTypeNode, NonNullTypeNode, NullValueNode, ObjectFieldNode, ObjectValueNode, OperationDefinitionNode, OperationTypeNode, SelectionNode, SelectionSetNode, Source, StringValueNode, TypeNode, ValueNode, VariableDefinitionNode, VariableNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, visit };
+declare function valueFromASTUntyped(node: ValueNode, variables?: Maybe<Record<string, any>>): unknown;
+declare function valueFromTypeNode(node: ValueNode, type: TypeNode, variables?: Maybe<Record<string, any>>): unknown;
+
+export { ASTNode, ASTReducer, ASTVisitFn, ASTVisitor, ArgumentNode, BREAK, BooleanValueNode, ConstArgumentNode, ConstDirectiveNode, ConstListValueNode, ConstObjectFieldNode, ConstObjectValueNode, ConstValueNode, DefinitionNode, DirectiveDefinitionNode, DirectiveNode, DocumentNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, EnumValueDefinitionNode, EnumValueNode, ExecutableDefinitionNode, FieldDefinitionNode, FieldNode, FloatValueNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InputValueDefinitionNode, IntValueNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, Kind, ListTypeNode, ListValueNode, Location, NameNode, NamedTypeNode, NonNullTypeNode, NullValueNode, ObjectFieldNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, ObjectValueNode, OperationDefinitionNode, OperationTypeDefinitionNode, OperationTypeNode, ScalarTypeDefinitionNode, ScalarTypeExtensionNode, SchemaDefinitionNode, SchemaExtensionNode, SelectionNode, SelectionSetNode, Source, StringValueNode, TypeDefinitionNode, TypeExtensionNode, TypeNode, TypeSystemDefinitionNode, TypeSystemExtensionNode, UnionTypeDefinitionNode, UnionTypeExtensionNode, ValueNode, VariableDefinitionNode, VariableNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, valueFromASTUntyped, valueFromTypeNode, visit };