@0no-co/graphql.web 0.0.0-canary-20230320141923

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 0no.co
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,465 @@
+type Maybe<T> = T | undefined | null;
+interface Extensions {
+    [extension: string]: unknown;
+}
+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>;
+}
+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<DefinitionNode>;
+    readonly loc?: Location;
+}
+type DefinitionNode = ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode;
+type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
+interface OperationDefinitionNode {
+    readonly kind: Kind.OPERATION_DEFINITION;
+    readonly operation: OperationTypeNode;
+    readonly name?: NameNode;
+    readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly selectionSet: SelectionSetNode;
+    readonly loc?: Location;
+}
+interface VariableDefinitionNode {
+    readonly kind: Kind.VARIABLE_DEFINITION;
+    readonly variable: VariableNode;
+    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 {
+    readonly kind: Kind.SELECTION_SET;
+    readonly selections: ReadonlyArray<SelectionNode>;
+    readonly loc?: Location;
+}
+declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
+interface FieldNode {
+    readonly kind: Kind.FIELD;
+    readonly alias?: NameNode;
+    readonly name: NameNode;
+    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;
+    readonly name: NameNode;
+    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;
+    readonly loc?: Location;
+}
+
+declare class GraphQLError extends Error {
+    readonly locations: ReadonlyArray<any> | undefined;
+    readonly path: ReadonlyArray<string | number> | 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(): any;
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+}
+
+declare function blockString(string: string): string;
+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;
+declare function visit<R>(root: ASTNode, visitor: ASTReducer<R>): R;
+type ASTVisitor = EnterLeaveVisitor<ASTNode> | KindVisitor;
+type KindVisitor = {
+    readonly [NodeT in ASTNode as NodeT['kind']]?: ASTVisitFn<NodeT> | EnterLeaveVisitor<NodeT>;
+};
+interface EnterLeaveVisitor<TVisitedNode extends ASTNode> {
+    readonly enter?: ASTVisitFn<TVisitedNode> | undefined;
+    readonly leave?: ASTVisitFn<TVisitedNode> | undefined;
+}
+type ASTVisitFn<Node extends ASTNode> = (node: Node, key: string | number | undefined, parent: ASTNode | ReadonlyArray<ASTNode> | undefined, path: ReadonlyArray<string | number>, ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => any;
+type ASTReducer<R> = {
+    readonly [NodeT in ASTNode as NodeT['kind']]?: {
+        readonly enter?: ASTVisitFn<NodeT>;
+        readonly leave: ASTReducerFn<NodeT, R>;
+    };
+};
+type ASTReducerFn<TReducedNode extends ASTNode, R> = (node: {
+    [K in keyof TReducedNode]: ReducedField<TReducedNode[K], R>;
+}, key: string | number | undefined, parent: ASTNode | ReadonlyArray<ASTNode> | undefined, path: ReadonlyArray<string | number>, ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => R;
+type ReducedField<T, R> = T extends null | undefined ? T : T extends ReadonlyArray<any> ? ReadonlyArray<R> : R;
+
+declare function printString(string: string): string;
+declare function printBlockString(string: string): string;
+declare function print(node: ASTNode): string;
+
+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 };