MAJOR RELEASEHEADprimary

- inlined vendored dependencies from npm
- makes this module work in Ende

1 files changed, 14536 insertions, 0 deletions

diff --git a/vendor/deps.d.ts b/vendor/deps.d.ts
new file mode 100644
index 0000000..ca493ce
--- /dev/null
+++ b/vendor/deps.d.ts
@@ -0,0 +1,14536 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/** @category Version */
+/** A string containing the version of the GraphQL.js library */
+export declare const version: string;
+/** An object containing the components of the GraphQL.js version string */
+export declare const versionInfo: Readonly<{
+	major: number;
+	minor: number;
+	patch: number;
+	preReleaseTag: string | null;
+}>;
+/** @category Development Mode */
+/**
+ * Enables GraphQL.js development mode checks for this module instance.
+ *
+ * Production entry points leave development mode disabled by default. Call this
+ * before constructing schemas or executing requests when additional development
+ * diagnostics should run.
+ * @example
+ * ```ts
+ * import { enableDevMode, isDevModeEnabled } from 'graphql/devMode';
+ *
+ * isDevModeEnabled(); // => false
+ * enableDevMode();
+ * isDevModeEnabled(); // => true
+ * ```
+ */
+export declare function enableDevMode(): void;
+/**
+ * Returns whether GraphQL.js development mode has been enabled for this module
+ * instance.
+ * @returns True when development mode is enabled.
+ * @example
+ * ```ts
+ * import { enableDevMode, isDevModeEnabled } from 'graphql/devMode';
+ *
+ * enableDevMode();
+ *
+ * isDevModeEnabled(); // => true
+ * ```
+ */
+export declare function isDevModeEnabled(): boolean;
+type Maybe<T> = null | undefined | T;
+interface ObjMap<T> {
+	[key: string]: T;
+}
+interface ReadOnlyObjMap<T> {
+	readonly [key: string]: T;
+}
+declare const NAME = "Name";
+type NAME = typeof NAME;
+declare const DOCUMENT = "Document";
+type DOCUMENT = typeof DOCUMENT;
+declare const OPERATION_DEFINITION = "OperationDefinition";
+type OPERATION_DEFINITION = typeof OPERATION_DEFINITION;
+declare const VARIABLE_DEFINITION = "VariableDefinition";
+type VARIABLE_DEFINITION = typeof VARIABLE_DEFINITION;
+declare const SELECTION_SET = "SelectionSet";
+type SELECTION_SET = typeof SELECTION_SET;
+declare const FIELD = "Field";
+type FIELD = typeof FIELD;
+declare const ARGUMENT = "Argument";
+type ARGUMENT = typeof ARGUMENT;
+declare const FRAGMENT_ARGUMENT = "FragmentArgument";
+type FRAGMENT_ARGUMENT = typeof FRAGMENT_ARGUMENT;
+declare const FRAGMENT_SPREAD = "FragmentSpread";
+type FRAGMENT_SPREAD = typeof FRAGMENT_SPREAD;
+declare const INLINE_FRAGMENT = "InlineFragment";
+type INLINE_FRAGMENT = typeof INLINE_FRAGMENT;
+declare const FRAGMENT_DEFINITION = "FragmentDefinition";
+type FRAGMENT_DEFINITION = typeof FRAGMENT_DEFINITION;
+declare const VARIABLE = "Variable";
+type VARIABLE = typeof VARIABLE;
+declare const INT = "IntValue";
+type INT = typeof INT;
+declare const FLOAT = "FloatValue";
+type FLOAT = typeof FLOAT;
+declare const STRING = "StringValue";
+type STRING = typeof STRING;
+declare const BOOLEAN = "BooleanValue";
+type BOOLEAN = typeof BOOLEAN;
+declare const NULL = "NullValue";
+type NULL = typeof NULL;
+declare const ENUM = "EnumValue";
+type ENUM = typeof ENUM;
+declare const LIST = "ListValue";
+type LIST = typeof LIST;
+declare const OBJECT = "ObjectValue";
+type OBJECT = typeof OBJECT;
+declare const OBJECT_FIELD = "ObjectField";
+type OBJECT_FIELD = typeof OBJECT_FIELD;
+declare const DIRECTIVE = "Directive";
+type DIRECTIVE = typeof DIRECTIVE;
+declare const NAMED_TYPE = "NamedType";
+type NAMED_TYPE = typeof NAMED_TYPE;
+declare const LIST_TYPE = "ListType";
+type LIST_TYPE = typeof LIST_TYPE;
+declare const NON_NULL_TYPE = "NonNullType";
+type NON_NULL_TYPE = typeof NON_NULL_TYPE;
+declare const SCHEMA_DEFINITION = "SchemaDefinition";
+type SCHEMA_DEFINITION = typeof SCHEMA_DEFINITION;
+declare const OPERATION_TYPE_DEFINITION = "OperationTypeDefinition";
+type OPERATION_TYPE_DEFINITION = typeof OPERATION_TYPE_DEFINITION;
+declare const SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition";
+type SCALAR_TYPE_DEFINITION = typeof SCALAR_TYPE_DEFINITION;
+declare const OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition";
+type OBJECT_TYPE_DEFINITION = typeof OBJECT_TYPE_DEFINITION;
+declare const FIELD_DEFINITION = "FieldDefinition";
+type FIELD_DEFINITION = typeof FIELD_DEFINITION;
+declare const INPUT_VALUE_DEFINITION = "InputValueDefinition";
+type INPUT_VALUE_DEFINITION = typeof INPUT_VALUE_DEFINITION;
+declare const INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition";
+type INTERFACE_TYPE_DEFINITION = typeof INTERFACE_TYPE_DEFINITION;
+declare const UNION_TYPE_DEFINITION = "UnionTypeDefinition";
+type UNION_TYPE_DEFINITION = typeof UNION_TYPE_DEFINITION;
+declare const ENUM_TYPE_DEFINITION = "EnumTypeDefinition";
+declare const ENUM_VALUE_DEFINITION = "EnumValueDefinition";
+type ENUM_VALUE_DEFINITION = typeof ENUM_VALUE_DEFINITION;
+declare const INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition";
+type INPUT_OBJECT_TYPE_DEFINITION = typeof INPUT_OBJECT_TYPE_DEFINITION;
+declare const DIRECTIVE_DEFINITION = "DirectiveDefinition";
+type DIRECTIVE_DEFINITION = typeof DIRECTIVE_DEFINITION;
+declare const SCHEMA_EXTENSION = "SchemaExtension";
+type SCHEMA_EXTENSION = typeof SCHEMA_EXTENSION;
+declare const DIRECTIVE_EXTENSION = "DirectiveExtension";
+type DIRECTIVE_EXTENSION = typeof DIRECTIVE_EXTENSION;
+declare const SCALAR_TYPE_EXTENSION = "ScalarTypeExtension";
+type SCALAR_TYPE_EXTENSION = typeof SCALAR_TYPE_EXTENSION;
+declare const OBJECT_TYPE_EXTENSION = "ObjectTypeExtension";
+type OBJECT_TYPE_EXTENSION = typeof OBJECT_TYPE_EXTENSION;
+declare const INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension";
+type INTERFACE_TYPE_EXTENSION = typeof INTERFACE_TYPE_EXTENSION;
+declare const UNION_TYPE_EXTENSION = "UnionTypeExtension";
+type UNION_TYPE_EXTENSION = typeof UNION_TYPE_EXTENSION;
+declare const ENUM_TYPE_EXTENSION = "EnumTypeExtension";
+type ENUM_TYPE_EXTENSION = typeof ENUM_TYPE_EXTENSION;
+declare const INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
+type INPUT_OBJECT_TYPE_EXTENSION = typeof INPUT_OBJECT_TYPE_EXTENSION;
+declare const TYPE_COORDINATE = "TypeCoordinate";
+type TYPE_COORDINATE = typeof TYPE_COORDINATE;
+declare const MEMBER_COORDINATE = "MemberCoordinate";
+type MEMBER_COORDINATE = typeof MEMBER_COORDINATE;
+declare const ARGUMENT_COORDINATE = "ArgumentCoordinate";
+type ARGUMENT_COORDINATE = typeof ARGUMENT_COORDINATE;
+declare const DIRECTIVE_COORDINATE = "DirectiveCoordinate";
+type DIRECTIVE_COORDINATE = typeof DIRECTIVE_COORDINATE;
+declare const DIRECTIVE_ARGUMENT_COORDINATE = "DirectiveArgumentCoordinate";
+type DIRECTIVE_ARGUMENT_COORDINATE = typeof DIRECTIVE_ARGUMENT_COORDINATE;
+type KindTypeMap = typeof Kind;
+interface Location {
+	line: number;
+	column: number;
+}
+/**
+ * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
+ * optional, but they are useful for clients who store GraphQL documents in source files.
+ * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might
+ * be useful for `name` to be `"Foo.graphql"` and location to be `{ line: 40, column: 1 }`.
+ * The `line` and `column` properties in `locationOffset` are 1-indexed.
+ */
+export declare class Source {
+	/** The GraphQL source text. */
+	body: string;
+	/** Name used in diagnostics for this source, such as a file path or request name. */
+	name: string;
+	/** One-indexed line and column where this source begins. */
+	locationOffset: Location;
+	/**
+	 * Creates a Source instance.
+	 * @param body - The GraphQL source text.
+	 * @param name - Name used in diagnostics for this source.
+	 * @param locationOffset - One-indexed line and column where this source begins.
+	 * @example
+	 * ```ts
+	 * import { Source } from 'graphql/language';
+	 *
+	 * const source = new Source('type Query { greeting: String }', 'schema.graphql', {
+	 *   line: 10,
+	 *   column: 1,
+	 * });
+	 *
+	 * source.body; // => 'type Query { greeting: String }'
+	 * source.name; // => 'schema.graphql'
+	 * source.locationOffset; // => { line: 10, column: 1 }
+	 * ```
+	 */
+	constructor(body: string, name?: string, locationOffset?: Location);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+}
+/** @category Lexing */
+/**
+ * An exported enum describing the different kinds of tokens that the
+ * lexer emits.
+ */
+export declare const TokenKind: {
+	readonly SOF: "<SOF>";
+	readonly EOF: "<EOF>";
+	readonly BANG: "!";
+	readonly DOLLAR: "$";
+	readonly AMP: "&";
+	readonly PAREN_L: "(";
+	readonly PAREN_R: ")";
+	readonly DOT: ".";
+	readonly SPREAD: "...";
+	readonly COLON: ":";
+	readonly EQUALS: "=";
+	readonly AT: "@";
+	readonly BRACKET_L: "[";
+	readonly BRACKET_R: "]";
+	readonly BRACE_L: "{";
+	readonly PIPE: "|";
+	readonly BRACE_R: "}";
+	readonly NAME: "Name";
+	readonly INT: "Int";
+	readonly FLOAT: "Float";
+	readonly STRING: "String";
+	readonly BLOCK_STRING: "BlockString";
+	readonly COMMENT: "Comment";
+};
+/**
+ * An exported enum describing the different kinds of tokens that the
+ * lexer emits.
+ */
+export type TokenKind = (typeof TokenKind)[keyof typeof TokenKind];
+/**
+ * Contains a range of UTF-8 character offsets and token references that
+ * identify the region of the source from which the AST derived.
+ */
+declare class Location$1 {
+	/** The character offset at which this Node begins. */
+	readonly start: number;
+	/** The character offset at which this Node ends. */
+	readonly end: number;
+	/** The Token at which this Node begins. */
+	readonly startToken: Token;
+	/** The Token at which this Node ends. */
+	readonly endToken: Token;
+	/** The Source document the AST represents. */
+	readonly source: Source;
+	/**
+	 * Creates a Location instance.
+	 * @param startToken - The start token.
+	 * @param endToken - The end token.
+	 * @param source - Source document used to derive error locations.
+	 * @example
+	 * ```ts
+	 * import { Location, Source, Token, TokenKind } from 'graphql/language';
+	 *
+	 * const source = new Source('{ hello }');
+	 * const startToken = new Token(TokenKind.BRACE_L, 0, 1, 1, 1);
+	 * const endToken = new Token(TokenKind.BRACE_R, 8, 9, 1, 9);
+	 * const location = new Location(startToken, endToken, source);
+	 *
+	 * location.start; // => 0
+	 * location.end; // => 9
+	 * location.source.body; // => '{ hello }'
+	 * ```
+	 */
+	constructor(startToken: Token, endToken: Token, source: Source);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a JSON representation of this location.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 *
+	 * const document = parse('{ hello }');
+	 * const location = document.loc?.toJSON();
+	 *
+	 * location; // => { start: 0, end: 9 }
+	 * ```
+	 */
+	toJSON(): {
+		start: number;
+		end: number;
+	};
+}
+/**
+ * Represents a range of characters represented by a lexical token
+ * within a Source.
+ */
+export declare class Token {
+	/** The kind of Token. */
+	readonly kind: TokenKind;
+	/** The character offset at which this Node begins. */
+	readonly start: number;
+	/** The character offset at which this Node ends. */
+	readonly end: number;
+	/** The 1-indexed line number on which this Token appears. */
+	readonly line: number;
+	/** The 1-indexed column number at which this Token begins. */
+	readonly column: number;
+	/**
+	 * For non-punctuation tokens, represents the interpreted value of the token.
+	 *
+	 * Note: is undefined for punctuation tokens, but typed as string for
+	 * convenience in the parser.
+	 */
+	readonly value: string;
+	/**
+	 * Tokens exist as nodes in a double-linked-list amongst all tokens
+	 * including ignored tokens. <SOF> is always the first node and <EOF>
+	 * the last.
+	 */
+	readonly prev: Token | null;
+	/** Next token in the token stream, including ignored tokens. */
+	readonly next: Token | null;
+	/**
+	 * Creates a Token instance.
+	 * @param kind - Token kind produced by lexical analysis.
+	 * @param start - Character offset where this token begins.
+	 * @param end - Character offset where this token ends.
+	 * @param line - One-indexed line number where this token begins.
+	 * @param column - One-indexed column number where this token begins.
+	 * @param value - Interpreted value for non-punctuation tokens.
+	 * @example
+	 * ```ts
+	 * import { Token, TokenKind } from 'graphql/language';
+	 *
+	 * const token = new Token(TokenKind.NAME, 2, 7, 1, 3, 'hello');
+	 *
+	 * token.kind; // => TokenKind.NAME
+	 * token.value; // => 'hello'
+	 * token.toJSON(); // => { kind: 'Name', value: 'hello', line: 1, column: 3 }
+	 * ```
+	 */
+	constructor(kind: TokenKind, start: number, end: number, line: number, column: number, value?: string);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a JSON representation of this token.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { Lexer, Source } from 'graphql/language';
+	 *
+	 * const lexer = new Lexer(new Source('{ hello }'));
+	 * const token = lexer.advance().toJSON();
+	 *
+	 * token; // => { kind: '{', value: undefined, line: 1, column: 1 }
+	 * ```
+	 */
+	toJSON(): {
+		kind: TokenKind;
+		value?: string;
+		line: number;
+		column: number;
+	};
+}
+/** The list of all possible AST node types. */
+export type ASTNode = NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentArgumentNode | 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 | DirectiveExtensionNode | TypeCoordinateNode | MemberCoordinateNode | ArgumentCoordinateNode | DirectiveCoordinateNode | DirectiveArgumentCoordinateNode;
+/** Utility type listing all nodes indexed by their kind. */
+export type ASTKindToNode = {
+	[NodeT in ASTNode as NodeT["kind"]]: NodeT;
+};
+/** An identifier in a GraphQL document. */
+export interface NameNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["NAME"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: string;
+}
+/** The root AST node for a parsed GraphQL document. */
+export interface DocumentNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DOCUMENT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Top-level executable and type-system definitions in this document. */
+	readonly definitions: ReadonlyArray<DefinitionNode>;
+	/** The number of lexical tokens parsed for this document, if token counting was enabled. */
+	readonly tokenCount?: number | undefined;
+}
+/** Any top-level definition that may appear in a GraphQL document. */
+export type DefinitionNode = ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode;
+/** Any executable definition that may appear in an operation document. */
+export type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
+/** A query, mutation, or subscription operation definition. */
+export interface OperationDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OPERATION_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** The operation selected for execution. */
+	readonly operation: OperationTypeNode;
+	/** Name node identifying this AST node. */
+	readonly name?: NameNode | undefined;
+	/** Variable definitions declared by this operation or fragment. */
+	readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+	/** Selections made by this operation, field, or fragment. */
+	readonly selectionSet: SelectionSetNode;
+}
+/**
+ * A narrowed OperationDefinitionNode for subscription operations.
+ * Subscription operations go through a distinct execution pipeline
+ * (source event stream + per-event execution), so narrowing the operation
+ * type allows functions in that pipeline to accept only valid input.
+ */
+export interface SubscriptionOperationDefinitionNode extends OperationDefinitionNode {
+	/** Subscription operation kind for this definition. */
+	readonly operation: (typeof OperationTypeNode)["SUBSCRIPTION"];
+}
+/**
+ * The operation types supported by GraphQL executable definitions.
+ * @category Kinds
+ */
+export declare const OperationTypeNode: {
+	readonly QUERY: "query";
+	readonly MUTATION: "mutation";
+	readonly SUBSCRIPTION: "subscription";
+};
+/**
+ * The operation types supported by GraphQL executable definitions.
+ * @category Kinds
+ */
+export type OperationTypeNode = (typeof OperationTypeNode)[keyof typeof OperationTypeNode];
+/** A variable declaration in an operation or experimental fragment definition. */
+export interface VariableDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["VARIABLE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** The variable being defined or referenced. */
+	readonly variable: VariableNode;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: TypeNode;
+	/** Default value used when no explicit value is supplied. */
+	readonly defaultValue?: ConstValueNode | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** A variable reference, such as `$id`. */
+export interface VariableNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["VARIABLE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+}
+/** A set of fields and fragments selected from an object, interface, or union. */
+export interface SelectionSetNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	kind: KindTypeMap["SELECTION_SET"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	loc?: Location$1 | undefined;
+	/** Fields and fragments contained in this selection set. */
+	selections: ReadonlyArray<SelectionNode>;
+}
+/** Any selection that may appear inside a selection set. */
+export type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
+/** A field selected in an executable GraphQL document. */
+export interface FieldNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["FIELD"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The response-key alias for this field, if one was supplied. */
+	readonly alias?: NameNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Arguments supplied to this field, directive, or coordinate. */
+	readonly arguments?: ReadonlyArray<ArgumentNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+	/** Selections made by this operation, field, or fragment. */
+	readonly selectionSet?: SelectionSetNode | undefined;
+}
+/** An argument supplied to a field or directive. */
+export interface ArgumentNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ARGUMENT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Parsed value represented by this node. */
+	readonly value: ValueNode;
+}
+/** An argument node whose value is guaranteed to be constant. */
+export interface ConstArgumentNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ARGUMENT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Parsed value represented by this node. */
+	readonly value: ConstValueNode;
+}
+/** Variable definition declared by a fragment argument. */
+export interface FragmentArgumentNode {
+	/** AST node kind for a fragment argument. */
+	readonly kind: KindTypeMap["FRAGMENT_ARGUMENT"];
+	/** Source location for this fragment argument. */
+	readonly loc?: Location$1 | undefined;
+	/** Variable name declared by this fragment argument. */
+	readonly name: NameNode;
+	/** Default value literal for this fragment argument, if provided. */
+	readonly value: ValueNode;
+}
+/** A named fragment spread, such as `...userFields`. */
+export interface FragmentSpreadNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["FRAGMENT_SPREAD"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Argument values supplied to the referenced fragment. */
+	readonly arguments?: ReadonlyArray<FragmentArgumentNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+}
+/** An inline fragment spread with an optional type condition. */
+export interface InlineFragmentNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INLINE_FRAGMENT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The type condition that limits where this fragment applies. */
+	readonly typeCondition?: NamedTypeNode | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+	/** Selections made by this operation, field, or fragment. */
+	readonly selectionSet: SelectionSetNode;
+}
+/** A reusable fragment definition declared in an executable document. */
+export interface FragmentDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["FRAGMENT_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Experimental variable definitions declared by this fragment definition. */
+	readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode> | undefined;
+	/** The type condition that limits where this fragment applies. */
+	readonly typeCondition: NamedTypeNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+	/** Selections made by this operation, field, or fragment. */
+	readonly selectionSet: SelectionSetNode;
+}
+/** Any value literal that may appear in an executable GraphQL document. */
+export type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
+/** Any value literal that is guaranteed not to contain a variable reference. */
+export type ConstValueNode = IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode;
+/** An integer value literal. */
+export interface IntValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: string;
+}
+/** A floating-point value literal. */
+export interface FloatValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["FLOAT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: string;
+}
+/** A string value literal. */
+export interface StringValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["STRING"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: string;
+	/** Whether this string was parsed from block string syntax. */
+	readonly block?: boolean | undefined;
+}
+/** A boolean value literal. */
+export interface BooleanValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["BOOLEAN"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: boolean;
+}
+/** A null value literal. */
+export interface NullValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["NULL"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+}
+/** An enum value literal. */
+export interface EnumValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ENUM"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Parsed value represented by this node. */
+	readonly value: string;
+}
+/** A list value literal. */
+export interface ListValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["LIST"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Values contained in this enum, list, or input-object definition. */
+	readonly values: ReadonlyArray<ValueNode>;
+}
+/** A list value literal whose elements are all constant values. */
+export interface ConstListValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["LIST"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Values contained in this enum, list, or input-object definition. */
+	readonly values: ReadonlyArray<ConstValueNode>;
+}
+/** An input object value literal. */
+export interface ObjectValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields: ReadonlyArray<ObjectFieldNode>;
+}
+/** An input object value literal whose fields are all constant values. */
+export interface ConstObjectValueNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields: ReadonlyArray<ConstObjectFieldNode>;
+}
+/** A field inside an input object value literal. */
+export interface ObjectFieldNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT_FIELD"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Parsed value represented by this node. */
+	readonly value: ValueNode;
+}
+/** A field inside a constant input object value literal. */
+export interface ConstObjectFieldNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT_FIELD"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Parsed value represented by this node. */
+	readonly value: ConstValueNode;
+}
+/** A directive applied to an executable or type-system location. */
+export interface DirectiveNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Arguments supplied to this field, directive, or coordinate. */
+	readonly arguments?: ReadonlyArray<ArgumentNode> | undefined;
+}
+/** A directive whose arguments are all constant values. */
+export interface ConstDirectiveNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Arguments supplied to this field, directive, or coordinate. */
+	readonly arguments?: ReadonlyArray<ConstArgumentNode> | undefined;
+}
+/** Any GraphQL type reference AST node. */
+export type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
+/** A named type reference. */
+export interface NamedTypeNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["NAMED_TYPE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+}
+/** A list type reference. */
+export interface ListTypeNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["LIST_TYPE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: TypeNode;
+}
+/** A non-null type reference. */
+export interface NonNullTypeNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["NON_NULL_TYPE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: NamedTypeNode | ListTypeNode;
+}
+/** Any type-system definition that may appear in a schema document. */
+export type TypeSystemDefinitionNode = SchemaDefinitionNode | TypeDefinitionNode | DirectiveDefinitionNode;
+/** A schema definition in a type-system document. */
+export interface SchemaDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["SCHEMA_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Root operation types declared by this schema definition or extension. */
+	readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
+}
+/** A root operation type declaration inside a schema definition or extension. */
+export interface OperationTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OPERATION_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The operation selected for execution. */
+	readonly operation: OperationTypeNode;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: NamedTypeNode;
+}
+/** Any named type definition that may appear in a schema document. */
+export type TypeDefinitionNode = ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | UnionTypeDefinitionNode | EnumTypeDefinitionNode | InputObjectTypeDefinitionNode;
+/** A scalar type definition in a type-system document. */
+export interface ScalarTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["SCALAR_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** An object type definition in a type-system document. */
+export interface ObjectTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;
+}
+/** A field definition declared by an object or interface type. */
+export interface FieldDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["FIELD_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Arguments supplied to this field, directive, or coordinate. */
+	readonly arguments?: ReadonlyArray<InputValueDefinitionNode> | undefined;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: TypeNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** An argument or input-field definition. */
+export interface InputValueDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INPUT_VALUE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: TypeNode;
+	/** Default value used when no explicit value is supplied. */
+	readonly defaultValue?: ConstValueNode | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** An interface type definition in a type-system document. */
+export interface InterfaceTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INTERFACE_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;
+}
+/** A union type definition in a type-system document. */
+export interface UnionTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["UNION_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Object types that belong to this union type. */
+	readonly types?: ReadonlyArray<NamedTypeNode> | undefined;
+}
+/** An enum type definition in a type-system document. */
+export interface EnumTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ENUM_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Values contained in this enum, list, or input-object definition. */
+	readonly values?: ReadonlyArray<EnumValueDefinitionNode> | undefined;
+}
+/** An enum value definition. */
+export interface EnumValueDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ENUM_VALUE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** An input object type definition in a type-system document. */
+export interface InputObjectTypeDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INPUT_OBJECT_TYPE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<InputValueDefinitionNode> | undefined;
+}
+/** A directive definition in a type-system document. */
+export interface DirectiveDefinitionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE_DEFINITION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** The optional GraphQL description associated with this definition. */
+	readonly description?: StringValueNode | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Arguments supplied to this field, directive, or coordinate. */
+	readonly arguments?: ReadonlyArray<InputValueDefinitionNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Whether this directive may appear more than once at the same location. */
+	readonly repeatable: boolean;
+	/** Locations where this directive may be applied. */
+	readonly locations: ReadonlyArray<NameNode>;
+}
+/** Any type-system extension that may appear in a schema extension document. */
+export type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode | DirectiveExtensionNode;
+/** A schema extension in a type-system document. */
+export interface SchemaExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["SCHEMA_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Root operation types declared by this schema definition or extension. */
+	readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode> | undefined;
+}
+/** Any named type extension that may appear in a schema extension document. */
+export type TypeExtensionNode = ScalarTypeExtensionNode | ObjectTypeExtensionNode | InterfaceTypeExtensionNode | UnionTypeExtensionNode | EnumTypeExtensionNode | InputObjectTypeExtensionNode;
+/** A scalar type extension. */
+export interface ScalarTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["SCALAR_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** An object type extension. */
+export interface ObjectTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["OBJECT_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;
+}
+/** An interface type extension. */
+export interface InterfaceTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INTERFACE_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;
+}
+/** A union type extension. */
+export interface UnionTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["UNION_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Object types that belong to this union type. */
+	readonly types?: ReadonlyArray<NamedTypeNode> | undefined;
+}
+/** An enum type extension. */
+export interface EnumTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ENUM_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Values contained in this enum, list, or input-object definition. */
+	readonly values?: ReadonlyArray<EnumValueDefinitionNode> | undefined;
+}
+/** An input object type extension. */
+export interface InputObjectTypeExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["INPUT_OBJECT_TYPE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields?: ReadonlyArray<InputValueDefinitionNode> | undefined;
+}
+/** A directive extension. */
+export interface DirectiveExtensionNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE_EXTENSION"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1 | undefined;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;
+}
+/** Any AST node representing a GraphQL schema coordinate. */
+export type SchemaCoordinateNode = TypeCoordinateNode | MemberCoordinateNode | ArgumentCoordinateNode | DirectiveCoordinateNode | DirectiveArgumentCoordinateNode;
+/** A schema coordinate that refers to a named type. */
+export interface TypeCoordinateNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["TYPE_COORDINATE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+}
+/** A schema coordinate that refers to a member of a named type. */
+export interface MemberCoordinateNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["MEMBER_COORDINATE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** The member name referenced by this schema coordinate. */
+	readonly memberName: NameNode;
+}
+/** A schema coordinate that refers to a field or directive argument. */
+export interface ArgumentCoordinateNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["ARGUMENT_COORDINATE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** The field name referenced by this schema coordinate. */
+	readonly fieldName: NameNode;
+	/** The argument name referenced by this schema coordinate. */
+	readonly argumentName: NameNode;
+}
+/** A schema coordinate that refers to a directive. */
+export interface DirectiveCoordinateNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE_COORDINATE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+}
+/** A schema coordinate that refers to a directive argument. */
+export interface DirectiveArgumentCoordinateNode {
+	/** The discriminator identifying the concrete AST or introspection kind. */
+	readonly kind: KindTypeMap["DIRECTIVE_ARGUMENT_COORDINATE"];
+	/** The source location for this AST node, if location tracking was enabled. */
+	readonly loc?: Location$1;
+	/** Name node identifying this AST node. */
+	readonly name: NameNode;
+	/** The argument name referenced by this schema coordinate. */
+	readonly argumentName: NameNode;
+}
+/** Represents a location in a Source. */
+export interface SourceLocation {
+	/** One-indexed line number in the source document. */
+	readonly line: number;
+	/** One-indexed column number in the source document. */
+	readonly column: number;
+}
+/**
+ * Takes a Source and a UTF-8 character offset, and returns the corresponding
+ * line and column as a SourceLocation.
+ * @param source - The source document that contains the position.
+ * @param position - The UTF-8 character offset in the source body.
+ * @returns The 1-indexed line and column for the given source position.
+ * @example
+ * ```ts
+ * import { Source, getLocation } from 'graphql/language';
+ *
+ * const source = new Source('type Query { hello: String }');
+ * const location = getLocation(source, 13);
+ *
+ * location; // => { line: 1, column: 14 }
+ * ```
+ */
+export declare function getLocation(source: Source, position: number): SourceLocation;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLErrorExtensions {
+	[attributeName: string]: unknown;
+}
+/**
+ * Custom formatted extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLFormattedErrorExtensions {
+	[attributeName: string]: unknown;
+}
+/** Options used to construct a GraphQLError. */
+export interface GraphQLErrorOptions {
+	/** AST node or nodes associated with this error. */
+	nodes?: ReadonlyArray<ASTNode> | ASTNode | null | undefined;
+	/** Source document used to derive error locations. */
+	source?: Maybe<Source>;
+	/** Character offsets in the source document associated with this error. */
+	positions?: Maybe<ReadonlyArray<number>>;
+	/** Response path where this error occurred during execution. */
+	path?: Maybe<ReadonlyArray<string | number>>;
+	/**
+	 * Original error that caused this GraphQLError, if one exists.
+	 * Deprecated in favor of `cause` to better align with JavaScript standards.
+	 * @deprecated Prefer `cause` instead.
+	 */
+	originalError?: Maybe<Error & {
+		readonly extensions?: unknown;
+	}>;
+	/** Cause of this GraphQLError, if one exists. */
+	cause?: unknown;
+	/** Extension fields to include in the formatted result. */
+	extensions?: Maybe<GraphQLErrorExtensions>;
+}
+/**
+ * A GraphQLError describes an Error found during the parse, validate, or
+ * execute phases of performing a GraphQL operation. In addition to a message
+ * and stack trace, it also includes information about the locations in a
+ * GraphQL document and/or execution result that correspond to the Error.
+ */
+export declare class GraphQLError extends Error {
+	/**
+	 * An array of `{ line, column }` locations within the source GraphQL document
+	 * which correspond to this error.
+	 *
+	 * Errors during validation often contain multiple locations, for example to
+	 * point out two things with the same name. Errors during execution include a
+	 * single location, the field which produced the error.
+	 *
+	 * Enumerable, and appears in the result of JSON.stringify().
+	 */
+	readonly locations: ReadonlyArray<SourceLocation> | undefined;
+	/**
+	 * An array describing the JSON-path into the execution response which
+	 * corresponds to this error. Only included for errors during execution.
+	 *
+	 * Enumerable, and appears in the result of JSON.stringify().
+	 */
+	readonly path: ReadonlyArray<string | number> | undefined;
+	/** An array of GraphQL AST Nodes corresponding to this error. */
+	readonly nodes: ReadonlyArray<ASTNode> | undefined;
+	/**
+	 * The source GraphQL document for the first location of this error.
+	 *
+	 * Note that if this Error represents more than one node, the source may not
+	 * represent nodes after the first node.
+	 */
+	readonly source: Source | undefined;
+	/**
+	 * An array of character offsets within the source GraphQL document
+	 * which correspond to this error.
+	 */
+	readonly positions: ReadonlyArray<number> | undefined;
+	/**
+	 * Original error that caused this GraphQLError, if one exists.
+	 * Deprecated in favor of `cause` to better align with JavaScript standards.
+	 * @deprecated Use `cause` instead.
+	 */
+	readonly originalError: Error | undefined;
+	/** Extension fields to add to the formatted error. */
+	readonly extensions: GraphQLErrorExtensions;
+	/**
+	 * Creates a GraphQLError instance.
+	 * @param message - Human-readable error message.
+	 * @param options - Error metadata such as source locations, response path, cause, original error, and extensions.
+	 * @example
+	 * ```ts
+	 * // Create an error from AST nodes and response metadata.
+	 * import { parse } from 'graphql/language';
+	 * import { GraphQLError } from 'graphql/error';
+	 *
+	 * const document = parse('{ greeting }');
+	 * const fieldNode = document.definitions[0].selectionSet.selections[0];
+	 * const error = new GraphQLError('Cannot query this field.', {
+	 *   nodes: fieldNode,
+	 *   path: ['greeting'],
+	 *   extensions: { code: 'FORBIDDEN' },
+	 * });
+	 *
+	 * error.message; // => 'Cannot query this field.'
+	 * error.locations; // => [{ line: 1, column: 3 }]
+	 * error.path; // => ['greeting']
+	 * error.extensions; // => { code: 'FORBIDDEN' }
+	 * ```
+	 * @example
+	 * ```ts
+	 * // This variant derives locations from source positions and preserves the cause.
+	 * import { Source } from 'graphql/language';
+	 * import { GraphQLError } from 'graphql/error';
+	 *
+	 * const source = new Source('{ greeting }');
+	 * const cause = new Error('Database unavailable.');
+	 * const error = new GraphQLError('Resolver failed.', {
+	 *   source,
+	 *   positions: [2],
+	 *   path: ['greeting'],
+	 *   cause,
+	 * });
+	 *
+	 * error.locations; // => [{ line: 1, column: 3 }]
+	 * error.path; // => ['greeting']
+	 * error.cause; // => cause
+	 * ```
+	 */
+	constructor(message: string, options?: GraphQLErrorOptions);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns this error as a human-readable message with source locations.
+	 * @returns The formatted error string.
+	 * @example
+	 * ```ts
+	 * import { Source } from 'graphql/language';
+	 * import { GraphQLError } from 'graphql/error';
+	 *
+	 * const error = new GraphQLError('Cannot query field "name".', {
+	 *   source: new Source('{ name }'),
+	 *   positions: [2],
+	 * });
+	 *
+	 * error.toString(); // => 'Cannot query field "name".\n\nGraphQL request:1:3\n1 | { name }\n  |   ^'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLError } from 'graphql/error';
+	 *
+	 * const error = new GraphQLError('Resolver failed.', {
+	 *   path: ['viewer', 'name'],
+	 *   extensions: { code: 'INTERNAL' },
+	 * });
+	 *
+	 * error.toJSON(); // => { message: 'Resolver failed.', path: ['viewer', 'name'], extensions: { code: 'INTERNAL' } }
+	 * ```
+	 */
+	toJSON(): GraphQLFormattedError;
+}
+/** See: https://spec.graphql.org/draft/#sec-Errors */
+export interface GraphQLFormattedError {
+	/**
+	 * A short, human-readable summary of the problem that **SHOULD NOT** change
+	 * from occurrence to occurrence of the problem, except for purposes of
+	 * localization.
+	 */
+	readonly message: string;
+	/**
+	 * If an error can be associated to a particular point in the requested
+	 * GraphQL document, it should contain a list of locations.
+	 */
+	readonly locations?: ReadonlyArray<SourceLocation>;
+	/**
+	 * 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.
+	 */
+	readonly path?: ReadonlyArray<string | number>;
+	/**
+	 * Reserved for implementors to extend the protocol however they see fit,
+	 * and hence there are no additional restrictions on its contents.
+	 */
+	readonly extensions?: GraphQLFormattedErrorExtensions;
+}
+/** Represents a linked response path from a field back to the root response. */
+interface Path {
+	/** The previous segment in the linked response path, or undefined at the root. */
+	readonly prev: Path | undefined;
+	/** The field name or list index for this response path segment. */
+	readonly key: string | number;
+	/** The runtime object type name associated with this path segment, if known. */
+	readonly typename: string | undefined;
+}
+/**
+ * Given a Path, return an Array of the path keys.
+ * @param path - The linked response path to flatten.
+ * @returns An array of response path keys from root to leaf.
+ * @example
+ * ```ts
+ * import { pathToArray } from 'graphql/jsutils/Path';
+ *
+ * const path = {
+ *   prev: {
+ *     prev: {
+ *       prev: undefined,
+ *       key: 'viewer',
+ *       typename: 'Query',
+ *     },
+ *     key: 'friends',
+ *     typename: 'User',
+ *   },
+ *   key: 0,
+ *   typename: undefined,
+ * };
+ *
+ * pathToArray(path); // => ['viewer', 'friends', 0]
+ * pathToArray(undefined); // => []
+ * ```
+ */
+declare function pathToArray(path: Maybe<Readonly<Path>>): Array<string | number>;
+type PromiseOrValue<T> = Promise<T> | T;
+/** @category Kinds */
+/** The set of allowed directive location values. */
+export declare const DirectiveLocation: {
+	/** Directive location for query operations. */
+	readonly QUERY: "QUERY";
+	/** Directive location for mutation operations. */
+	readonly MUTATION: "MUTATION";
+	/** Directive location for subscription operations. */
+	readonly SUBSCRIPTION: "SUBSCRIPTION";
+	/** Directive location for field selections. */
+	readonly FIELD: "FIELD";
+	/** Directive location for fragment definitions. */
+	readonly FRAGMENT_DEFINITION: "FRAGMENT_DEFINITION";
+	/** Directive location for fragment spreads. */
+	readonly FRAGMENT_SPREAD: "FRAGMENT_SPREAD";
+	/** Directive location for inline fragments. */
+	readonly INLINE_FRAGMENT: "INLINE_FRAGMENT";
+	/** Directive location for variable definitions. */
+	readonly VARIABLE_DEFINITION: "VARIABLE_DEFINITION";
+	/** Directive location for fragment variable definitions. */
+	readonly FRAGMENT_VARIABLE_DEFINITION: "FRAGMENT_VARIABLE_DEFINITION";
+	/** Directive location for schema definitions and extensions. */
+	readonly SCHEMA: "SCHEMA";
+	/** Directive location for scalar type definitions and extensions. */
+	readonly SCALAR: "SCALAR";
+	/** Directive location for object type definitions and extensions. */
+	readonly OBJECT: "OBJECT";
+	/** Directive location for field definitions. */
+	readonly FIELD_DEFINITION: "FIELD_DEFINITION";
+	/** Directive location for argument definitions. */
+	readonly ARGUMENT_DEFINITION: "ARGUMENT_DEFINITION";
+	/** Directive location for interface type definitions and extensions. */
+	readonly INTERFACE: "INTERFACE";
+	/** Directive location for union type definitions and extensions. */
+	readonly UNION: "UNION";
+	/** Directive location for enum type definitions and extensions. */
+	readonly ENUM: "ENUM";
+	/** Directive location for enum value definitions. */
+	readonly ENUM_VALUE: "ENUM_VALUE";
+	/** Directive location for input object type definitions and extensions. */
+	readonly INPUT_OBJECT: "INPUT_OBJECT";
+	/** Directive location for input object field definitions. */
+	readonly INPUT_FIELD_DEFINITION: "INPUT_FIELD_DEFINITION";
+	/** Directive location for directive definitions and extensions. */
+	readonly DIRECTIVE_DEFINITION: "DIRECTIVE_DEFINITION";
+};
+/** The set of allowed directive location values. */
+export type DirectiveLocation = (typeof DirectiveLocation)[keyof typeof DirectiveLocation];
+/**
+ * Test if the given value is a GraphQL directive.
+ * @param directive - Value to inspect.
+ * @returns True when the value is a GraphQLDirective.
+ * @example
+ * ```ts
+ * import { DirectiveLocation } from 'graphql/language';
+ * import { GraphQLDirective, GraphQLString, isDirective } from 'graphql/type';
+ *
+ * const upper = new GraphQLDirective({
+ *   name: 'upper',
+ *   locations: [DirectiveLocation.FIELD_DEFINITION],
+ * });
+ *
+ * isDirective(upper); // => true
+ * isDirective(GraphQLString); // => false
+ * ```
+ */
+export declare function isDirective(directive: unknown): directive is GraphQLDirective;
+/**
+ * Returns the value as a GraphQLDirective, or throws if it is not a directive.
+ * @param directive - Value to inspect.
+ * @returns The value typed as a GraphQLDirective.
+ * @example
+ * ```ts
+ * import { DirectiveLocation } from 'graphql/language';
+ * import { assertDirective, GraphQLDirective, GraphQLString } from 'graphql/type';
+ *
+ * const upper = new GraphQLDirective({
+ *   name: 'upper',
+ *   locations: [DirectiveLocation.FIELD_DEFINITION],
+ * });
+ *
+ * assertDirective(upper); // => upper
+ * assertDirective(GraphQLString); // throws an error
+ * ```
+ */
+export declare function assertDirective(directive: unknown): GraphQLDirective;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLDirectiveExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Directives are used by the GraphQL runtime as a way of modifying execution
+ * behavior. Type system creators will usually not create these directly.
+ */
+export declare class GraphQLDirective implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Locations where this directive may be applied. */
+	locations: ReadonlyArray<DirectiveLocation>;
+	/** Arguments accepted by this field or directive. */
+	args: ReadonlyArray<GraphQLArgument>;
+	/** Whether this directive may appear more than once at the same location. */
+	isRepeatable: boolean;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLDirectiveExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<DirectiveDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
+	/**
+	 * Creates a GraphQLDirective instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { DirectiveLocation, parse } from 'graphql/language';
+	 * import {
+	 *   GraphQLBoolean,
+	 *   GraphQLDirective,
+	 *   GraphQLInt,
+	 *   GraphQLNonNull,
+	 * } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   directive @cacheControl(maxAge: Int) repeatable on FIELD_DEFINITION
+	 *   extend directive @cacheControl(maxAge: Int) on FIELD_DEFINITION
+	 * `);
+	 * const definition = document.definitions[0];
+	 *
+	 * const cacheControl = new GraphQLDirective({
+	 *   name: 'cacheControl',
+	 *   description: 'Controls HTTP cache hints for a field.',
+	 *   locations: [DirectiveLocation.FIELD_DEFINITION],
+	 *   args: {
+	 *     inheritMaxAge: {
+	 *       description: 'Inherit the parent cache hint.',
+	 *       type: new GraphQLNonNull(GraphQLBoolean),
+	 *       default: { value: false },
+	 *       deprecationReason: 'Use maxAge instead.',
+	 *       extensions: { scope: 'cache' },
+	 *     },
+	 *     maxAge: {
+	 *       type: GraphQLInt,
+	 *       astNode: definition.arguments[0],
+	 *     },
+	 *   },
+	 *   isRepeatable: true,
+	 *   deprecationReason: 'Use @cache instead.',
+	 *   extensions: { scope: 'cache' },
+	 *   astNode: definition,
+	 *   extensionASTNodes: [document.definitions[1]],
+	 * });
+	 *
+	 * cacheControl.name; // => 'cacheControl'
+	 * cacheControl.description; // => 'Controls HTTP cache hints for a field.'
+	 * cacheControl.args[0].name; // => 'inheritMaxAge'
+	 * cacheControl.args[0].default.value; // => false
+	 * cacheControl.isRepeatable; // => true
+	 * cacheControl.extensions; // => { scope: 'cache' }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLDirectiveConfig>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { DirectiveLocation } from 'graphql/language';
+	 * import { GraphQLDirective, GraphQLString } from 'graphql/type';
+	 *
+	 * const tag = new GraphQLDirective({
+	 *   name: 'tag',
+	 *   locations: [DirectiveLocation.FIELD_DEFINITION],
+	 *   args: {
+	 *     name: { type: GraphQLString },
+	 *   },
+	 * });
+	 *
+	 * const config = tag.toConfig();
+	 * const tagCopy = new GraphQLDirective(config);
+	 *
+	 * config.args.name.type; // => GraphQLString
+	 * tagCopy.args[0].name; // => 'name'
+	 * ```
+	 */
+	toConfig(): GraphQLDirectiveNormalizedConfig;
+	/**
+	 * Returns the schema coordinate identifying this directive.
+	 * @returns The directive schema coordinate.
+	 * @example
+	 * ```ts
+	 * import { DirectiveLocation } from 'graphql/language';
+	 * import { GraphQLDirective } from 'graphql/type';
+	 *
+	 * const tag = new GraphQLDirective({
+	 *   name: 'tag',
+	 *   locations: [DirectiveLocation.FIELD_DEFINITION],
+	 * });
+	 *
+	 * tag.toString(); // => '@tag'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { DirectiveLocation } from 'graphql/language';
+	 * import { GraphQLDirective } from 'graphql/type';
+	 *
+	 * const tag = new GraphQLDirective({
+	 *   name: 'tag',
+	 *   locations: [DirectiveLocation.FIELD_DEFINITION],
+	 * });
+	 *
+	 * tag.toJSON(); // => '@tag'
+	 * JSON.stringify({ directive: tag }); // => '{"directive":"@tag"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/** Configuration used to construct a GraphQLDirective. */
+export interface GraphQLDirectiveConfig {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Locations where this directive may be applied. */
+	locations: ReadonlyArray<DirectiveLocation>;
+	/** Arguments accepted by this field or directive. */
+	args?: Maybe<ObjMap<GraphQLArgumentConfig>>;
+	/** Whether this directive may appear more than once at the same location. */
+	isRepeatable?: Maybe<boolean>;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason?: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLDirectiveExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<DirectiveDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<DirectiveExtensionNode>>;
+}
+interface GraphQLDirectiveNormalizedConfig extends GraphQLDirectiveConfig {
+	args: GraphQLFieldNormalizedConfigArgumentMap;
+	isRepeatable: boolean;
+	extensions: Readonly<GraphQLDirectiveExtensions>;
+	extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
+}
+/** Used to conditionally include fields or fragments. */
+export declare const GraphQLIncludeDirective: GraphQLDirective;
+/** Used to conditionally skip (exclude) fields or fragments. */
+export declare const GraphQLSkipDirective: GraphQLDirective;
+/**
+ * Experimental directive used to conditionally defer fragments.
+ *
+ * This directive is exported for schemas that explicitly opt in to incremental
+ * delivery. It is not included in `specifiedDirectives`.
+ */
+export declare const GraphQLDeferDirective: GraphQLDirective;
+/**
+ * Experimental directive used to conditionally stream list fields.
+ *
+ * This directive is exported for schemas that explicitly opt in to incremental
+ * delivery. It is not included in `specifiedDirectives`.
+ */
+export declare const GraphQLStreamDirective: GraphQLDirective;
+/** Constant string used for default reason for a deprecation. */
+export declare const DEFAULT_DEPRECATION_REASON = "No longer supported";
+/**
+ * Used to declare element of a GraphQL schema as deprecated.
+ *
+ * The `reason` argument is non-null and defaults to
+ * `DEFAULT_DEPRECATION_REASON`.
+ */
+export declare const GraphQLDeprecatedDirective: GraphQLDirective;
+/** Used to provide a URL for specifying the behavior of custom scalar definitions. */
+export declare const GraphQLSpecifiedByDirective: GraphQLDirective;
+/** Used to indicate an Input Object is a OneOf Input Object. */
+export declare const GraphQLOneOfDirective: GraphQLDirective;
+/**
+ * Full list of stable directives specified by GraphQL.js.
+ *
+ * Experimental `@defer` and `@stream` are exported separately and are not
+ * included in this list.
+ */
+export declare const specifiedDirectives: ReadonlyArray<GraphQLDirective>;
+/**
+ * Returns true when the directive is one of the directives specified by GraphQL.
+ * @param directive - Directive to inspect.
+ * @returns True when the directive is specified by GraphQL.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLDirective,
+ *   GraphQLIncludeDirective,
+ *   isSpecifiedDirective,
+ * } from 'graphql/type';
+ * import { DirectiveLocation } from 'graphql/language';
+ *
+ * const customDirective = new GraphQLDirective({
+ *   name: 'auth',
+ *   locations: [DirectiveLocation.FIELD_DEFINITION],
+ * });
+ *
+ * isSpecifiedDirective(GraphQLIncludeDirective); // => true
+ * isSpecifiedDirective(customDirective); // => false
+ * ```
+ */
+export declare function isSpecifiedDirective(directive: GraphQLDirective): boolean;
+/**
+ * Maximum possible Int value as per GraphQL Spec (32-bit signed integer).
+ * n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe up-to 2^53 - 1
+ */
+export declare const GRAPHQL_MAX_INT = 2147483647;
+/**
+ * Minimum possible Int value as per GraphQL Spec (32-bit signed integer).
+ * n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe starting at -(2^53 - 1)
+ */
+export declare const GRAPHQL_MIN_INT = -2147483648;
+/** The built-in `Int` scalar type. */
+export declare const GraphQLInt: GraphQLScalarType<number>;
+/** The built-in `Float` scalar type. */
+export declare const GraphQLFloat: GraphQLScalarType<number>;
+/** The built-in `String` scalar type. */
+export declare const GraphQLString: GraphQLScalarType<string>;
+/** The built-in `Boolean` scalar type. */
+export declare const GraphQLBoolean: GraphQLScalarType<boolean>;
+/** The built-in `ID` scalar type. */
+export declare const GraphQLID: GraphQLScalarType<string>;
+/** All built-in scalar types defined by the GraphQL specification. */
+export declare const specifiedScalarTypes: ReadonlyArray<GraphQLScalarType>;
+/**
+ * Returns true when the scalar type is one of the scalars specified by GraphQL.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the scalar type is one of the scalars specified by GraphQL.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLScalarType,
+ *   GraphQLString,
+ *   isSpecifiedScalarType,
+ * } from 'graphql/type';
+ *
+ * const DateTime = new GraphQLScalarType({
+ *   name: 'DateTime',
+ * });
+ *
+ * isSpecifiedScalarType(GraphQLString); // => true
+ * isSpecifiedScalarType(DateTime); // => false
+ * ```
+ */
+export declare function isSpecifiedScalarType(type: GraphQLNamedType): boolean;
+/** The introspection type describing a GraphQL schema. */
+export declare const __Schema: GraphQLObjectType;
+/** The introspection type describing a GraphQL directive. */
+export declare const __Directive: GraphQLObjectType;
+/** The introspection enum describing directive locations. */
+export declare const __DirectiveLocation: GraphQLEnumType;
+/** The introspection type describing GraphQL types. */
+export declare const __Type: GraphQLObjectType;
+/** The introspection type describing object and interface fields. */
+export declare const __Field: GraphQLObjectType;
+/** The introspection type describing arguments and input fields. */
+export declare const __InputValue: GraphQLObjectType;
+/** The introspection type describing enum values. */
+export declare const __EnumValue: GraphQLObjectType;
+/**
+ * The introspection enum describing the different kinds of GraphQL types.
+ * @category Introspection
+ */
+export declare const TypeKind: {
+	readonly SCALAR: "SCALAR";
+	readonly OBJECT: "OBJECT";
+	readonly INTERFACE: "INTERFACE";
+	readonly UNION: "UNION";
+	readonly ENUM: "ENUM";
+	readonly INPUT_OBJECT: "INPUT_OBJECT";
+	readonly LIST: "LIST";
+	readonly NON_NULL: "NON_NULL";
+};
+/**
+ * The introspection enum describing the different kinds of GraphQL types.
+ * @category Introspection
+ */
+export type TypeKind = (typeof TypeKind)[keyof typeof TypeKind];
+/** The introspection enum describing GraphQL type kinds. */
+export declare const __TypeKind: GraphQLEnumType;
+/**
+ * Note that these are GraphQLField and not GraphQLFieldConfig,
+ * so the format for args is different.
+ */
+export declare const SchemaMetaFieldDef: GraphQLField<unknown, unknown>;
+/** The `__type` meta field definition used by introspection. */
+export declare const TypeMetaFieldDef: GraphQLField<unknown, unknown>;
+/** The `__typename` meta field definition used by execution and introspection. */
+export declare const TypeNameMetaFieldDef: GraphQLField<unknown, unknown>;
+/** All introspection types defined by the GraphQL specification. */
+export declare const introspectionTypes: ReadonlyArray<GraphQLNamedType>;
+/**
+ * Returns true when the type is one of the built-in introspection types.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the type is one of the built-in introspection types.
+ * @example
+ * ```ts
+ * import { GraphQLString, isIntrospectionType, __Type } from 'graphql/type';
+ *
+ * isIntrospectionType(__Type); // => true
+ * isIntrospectionType(GraphQLString); // => false
+ * ```
+ */
+export declare function isIntrospectionType(type: GraphQLNamedType): boolean;
+/**
+ * Implements the "Type Validation" sub-sections of the specification's
+ * "Type System" section.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the Schema is valid.
+ * @param schema - GraphQL schema to use.
+ * @returns Schema validation errors, or an empty array when the schema is valid.
+ * @example
+ * ```ts
+ * import { validateSchema } from 'graphql/type';
+ * import { buildSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ * const errors = validateSchema(schema);
+ *
+ * errors; // => []
+ * ```
+ */
+export declare function validateSchema(schema: GraphQLSchema): ReadonlyArray<GraphQLError>;
+/**
+ * Utility function which asserts a schema is valid by throwing an error if
+ * it is invalid.
+ * @param schema - GraphQL schema to use.
+ * @example
+ * ```ts
+ * import { assertValidSchema } from 'graphql/type';
+ * import { buildSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * assertValidSchema(schema); // does not throw
+ * ```
+ */
+export declare function assertValidSchema(schema: GraphQLSchema): void;
+/** @category Names */
+/**
+ * Upholds the spec rules about naming.
+ * @param name - The GraphQL name to validate.
+ * @returns The validated GraphQL name.
+ * @example
+ * ```ts
+ * import { assertName } from 'graphql/type';
+ *
+ * assertName('User'); // => 'User'
+ * assertName('123User'); // throws an error
+ * ```
+ */
+export declare function assertName(name: string): string;
+/**
+ * Upholds the spec rules about naming enum values.
+ * @param name - The GraphQL name to validate.
+ * @returns The validated GraphQL name.
+ * @example
+ * ```ts
+ * import { assertEnumValueName } from 'graphql/type';
+ *
+ * assertEnumValueName('ACTIVE'); // => 'ACTIVE'
+ * assertEnumValueName('true'); // throws an error
+ * ```
+ */
+export declare function assertEnumValueName(name: string): string;
+interface GraphQLVariableSignature {
+	name: string;
+	type: GraphQLInputType;
+	defaultValue?: never;
+	default: {
+		literal: ConstValueNode;
+	} | undefined;
+}
+interface FragmentVariableValues {
+	readonly sources: ReadOnlyObjMap<FragmentVariableValueSource>;
+	readonly coerced: ReadOnlyObjMap<unknown>;
+}
+interface FragmentVariableValueSource {
+	readonly signature: GraphQLVariableSignature;
+	readonly value?: ValueNode;
+	readonly fragmentVariableValues?: FragmentVariableValues;
+}
+interface FragmentDetails {
+	definition: FragmentDefinitionNode;
+	variableSignatures?: ObjMap<GraphQLVariableSignature> | undefined;
+}
+/**
+ * Coerced variable values prepared for execution.
+ *
+ * The `coerced` map contains runtime values keyed by variable name. The
+ * `sources` map records whether each value came from request input, an operation
+ * default, or a fragment-variable default so utilities can preserve defaults
+ * when replacing variables in literals.
+ */
+export interface VariableValues {
+	/** Source metadata for each variable value keyed by variable name. */
+	readonly sources: ReadOnlyObjMap<VariableValueSource>;
+	/** Coerced runtime variable values keyed by variable name. */
+	readonly coerced: ReadOnlyObjMap<unknown>;
+}
+interface VariableValueSource {
+	readonly signature: GraphQLVariableSignature;
+	readonly value?: unknown;
+}
+type VariableValuesOrErrors = {
+	variableValues: VariableValues;
+	errors?: never;
+} | {
+	errors: ReadonlyArray<GraphQLError>;
+	variableValues?: never;
+};
+/**
+ * Prepares an object map of variableValues of the correct type based on the
+ * provided variable definitions and arbitrary input. If the input cannot be
+ * parsed to match the variable definitions, GraphQLError values are returned.
+ *
+ * Note: Returned maps use null prototypes to avoid collisions with
+ * Object prototype properties.
+ * @param schema - GraphQL schema to use.
+ * @param varDefNodes - The variable definition AST nodes to coerce.
+ * @param inputs - The runtime variable values keyed by variable name.
+ * @param options - Optional configuration for this operation.
+ * @param [options.maxErrors] - Maximum number of coercion errors to report.
+ * @param [options.hideSuggestions] - Whether suggestion text should be omitted
+ * from errors.
+ * @returns Coerced variable values with source metadata, or request errors.
+ * @example
+ * ```ts
+ * // Coerce provided variables and apply operation defaults.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($stars: Int!, $limit: Int = 10) {
+ *     reviews(stars: $stars, limit: $limit)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(schema, operation.variableDefinitions, {
+ *   stars: '5',
+ * });
+ *
+ * assert('variableValues' in result);
+ *
+ * result.variableValues.coerced; // => { stars: 5, limit: 10 }
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses maxErrors to cap reported coercion errors.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput!): String
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($first: ReviewInput!, $second: ReviewInput!) {
+ *     first: review(input: $first)
+ *     second: review(input: $second)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { first: { stars: 'bad' }, second: { stars: 'also bad' } },
+ *   { maxErrors: 1 },
+ * );
+ *
+ * assert('errors' in result);
+ *
+ * result.errors.length; // => 2
+ * result.errors[1].message; // matches /error limit reached/
+ * ```
+ */
+export declare function getVariableValues(schema: GraphQLSchema, varDefNodes: ReadonlyArray<VariableDefinitionNode>, inputs: {
+	readonly [variable: string]: unknown;
+}, options?: {
+	maxErrors?: number;
+	hideSuggestions?: boolean;
+}): VariableValuesOrErrors;
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: Returned value uses a null prototype to avoid collisions with
+ * JavaScript's own property names.
+ * @param def - Field or directive definition that declares the arguments.
+ * @param node - Field or directive AST node supplying argument literals.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns A map of coerced argument values.
+ * @example
+ * ```ts
+ * // Read literal argument values and defaults.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('{ reviews(stars: 5) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getArgumentValues(fieldDef, fieldNode); // => { stars: 5, limit: 10 }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves argument values from operation variables.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues, getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('query ($stars: Int!) { reviews(stars: $stars) }');
+ * const operation = document.definitions[0];
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ * const variables = getVariableValues(schema, operation.variableDefinitions, {
+ *   stars: '5',
+ * });
+ *
+ * assert('variableValues' in variables);
+ *
+ * getArgumentValues(fieldDef, fieldNode, variables.variableValues); // => { stars: 5 }
+ * getArgumentValues(fieldDef, fieldNode); // throws an error
+ * ```
+ */
+export declare function getArgumentValues(def: GraphQLField<unknown, unknown> | GraphQLDirective, node: FieldNode | DirectiveNode, variableValues?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): ObjMap<unknown>;
+/**
+ * Prepares an object map of argument values given a directive definition
+ * and a AST node which may contain directives. Optionally also accepts a map
+ * of variable values.
+ *
+ * If the directive does not exist on the node, returns undefined.
+ *
+ * Note: Returned value uses a null prototype to avoid collisions with
+ * JavaScript's own property names.
+ * @param directiveDef - Directive definition to read argument definitions from.
+ * @param node - AST node that may contain directives.
+ * @param node.directives - The directives on the AST node.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns A map of coerced directive argument values, or undefined when absent.
+ * @example
+ * ```ts
+ * // Read literal directive arguments from a node.
+ * import { parse } from 'graphql/language';
+ * import { GraphQLSkipDirective } from 'graphql/type';
+ * import { getDirectiveValues } from 'graphql/execution';
+ *
+ * const document = parse('{ name @skip(if: true) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getDirectiveValues(GraphQLSkipDirective, fieldNode); // => { if: true }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves directive arguments from variables and handles absent directives.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { GraphQLIncludeDirective } from 'graphql/type';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getDirectiveValues, getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { name: String }');
+ * const document = parse(
+ *   'query ($includeName: Boolean!) { name @include(if: $includeName) }',
+ * );
+ * const operation = document.definitions[0];
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ * const variables = getVariableValues(schema, operation.variableDefinitions, {
+ *   includeName: false,
+ * });
+ *
+ * assert('variableValues' in variables);
+ *
+ * getDirectiveValues(
+ *   GraphQLIncludeDirective,
+ *   fieldNode,
+ *   variables.variableValues,
+ * ); // => { if: false }
+ * getDirectiveValues(GraphQLIncludeDirective, { directives: [] }); // => undefined
+ * ```
+ */
+export declare function getDirectiveValues(directiveDef: GraphQLDirective, node: {
+	readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
+}, variableValues?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): undefined | ObjMap<unknown>;
+/** These are all of the possible kinds of types. */
+export type GraphQLType = GraphQLNamedType | GraphQLWrappingType;
+/**
+ * Returns true when the value is any GraphQL type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is any GraphQL type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { GraphQLList, GraphQLString, isType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * isType(GraphQLString); // => true
+ * isType(new GraphQLList(GraphQLString)); // => true
+ * isType(schema.getType('Query')); // => true
+ * isType('String'); // => false
+ * ```
+ */
+export declare function isType(type: unknown): type is GraphQLType;
+/**
+ * Returns the value as a GraphQL type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const queryType = assertType(schema.getType('Query'));
+ *
+ * queryType.toString(); // => 'Query'
+ * assertType('Query'); // throws an error
+ * ```
+ */
+export declare function assertType(type: unknown): GraphQLType;
+/**
+ * There are predicates for each kind of GraphQL type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLScalarType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isScalarType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   scalar DateTime
+ *
+ *   type Query {
+ *     createdAt: DateTime
+ *   }
+ * `);
+ *
+ * isScalarType(schema.getType('DateTime')); // => true
+ * isScalarType(schema.getType('Query')); // => false
+ * ```
+ */
+export declare function isScalarType(type: unknown): type is GraphQLScalarType;
+/**
+ * Returns the value as a GraphQLScalarType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLScalarType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertScalarType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   scalar DateTime
+ *
+ *   type Query {
+ *     createdAt: DateTime
+ *   }
+ * `);
+ *
+ * const dateTimeType = assertScalarType(schema.getType('DateTime'));
+ *
+ * dateTimeType.name; // => 'DateTime'
+ * assertScalarType(schema.getType('Query')); // throws an error
+ * ```
+ */
+export declare function assertScalarType(type: unknown): GraphQLScalarType;
+/**
+ * Returns true when the value is a GraphQLObjectType.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLObjectType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isObjectType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type User {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     user: User
+ *   }
+ * `);
+ *
+ * isObjectType(schema.getType('User')); // => true
+ * isObjectType(schema.getType('ReviewInput')); // => false
+ * ```
+ */
+export declare function isObjectType(type: unknown): type is GraphQLObjectType;
+/**
+ * Returns the value as a GraphQLObjectType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLObjectType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertObjectType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type User {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     user: User
+ *   }
+ * `);
+ *
+ * const userType = assertObjectType(schema.getType('User'));
+ *
+ * Object.keys(userType.getFields()); // => ['name']
+ * assertObjectType(schema.getType('ReviewInput')); // throws an error
+ * ```
+ */
+export declare function assertObjectType(type: unknown): GraphQLObjectType;
+/**
+ * Returns true when the value is a resolved GraphQL field definition.
+ * @param field - Value to inspect.
+ * @returns True when the value is a GraphQLField.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isField } from 'graphql/type';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const field = schema.getQueryType().getFields().greeting;
+ *
+ * isField(field); // => true
+ * isField(schema.getQueryType()); // => false
+ * ```
+ */
+export declare function isField(field: unknown): field is GraphQLField;
+/**
+ * Returns the value as a GraphQLField, or throws if it is not one.
+ * @param field - Value to inspect.
+ * @returns The value typed as a GraphQLField.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertField } from 'graphql/type';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const field = assertField(schema.getQueryType().getFields().greeting);
+ *
+ * field.name; // => 'greeting'
+ * assertField(schema.getQueryType()); // throws an error
+ * ```
+ */
+export declare function assertField(field: unknown): GraphQLField;
+/**
+ * Returns true when the value is a resolved GraphQL argument definition.
+ * @param arg - Value to inspect.
+ * @returns True when the value is a GraphQLArgument.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isArgument } from 'graphql/type';
+ *
+ * const schema = buildSchema('type Query { greeting(name: String): String }');
+ * const arg = schema.getQueryType().getFields().greeting.args[0];
+ *
+ * isArgument(arg); // => true
+ * isArgument(schema.getQueryType()); // => false
+ * ```
+ */
+export declare function isArgument(arg: unknown): arg is GraphQLArgument;
+/**
+ * Returns the value as a GraphQLArgument, or throws if it is not one.
+ * @param arg - Value to inspect.
+ * @returns The value typed as a GraphQLArgument.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertArgument } from 'graphql/type';
+ *
+ * const schema = buildSchema('type Query { greeting(name: String): String }');
+ * const arg = assertArgument(schema.getQueryType().getFields().greeting.args[0]);
+ *
+ * arg.name; // => 'name'
+ * assertArgument(schema.getQueryType()); // throws an error
+ * ```
+ */
+export declare function assertArgument(arg: unknown): GraphQLArgument;
+/**
+ * Returns true when the value is a GraphQLInterfaceType.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLInterfaceType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isInterfaceType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ *
+ * isInterfaceType(schema.getType('Node')); // => true
+ * isInterfaceType(schema.getType('User')); // => false
+ * ```
+ */
+export declare function isInterfaceType(type: unknown): type is GraphQLInterfaceType;
+/**
+ * Returns the value as a GraphQLInterfaceType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLInterfaceType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertInterfaceType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ *
+ * const nodeType = assertInterfaceType(schema.getType('Node'));
+ *
+ * nodeType.name; // => 'Node'
+ * assertInterfaceType(schema.getType('User')); // throws an error
+ * ```
+ */
+export declare function assertInterfaceType(type: unknown): GraphQLInterfaceType;
+/**
+ * Returns true when the value is a GraphQLUnionType.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLUnionType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isUnionType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Photo {
+ *     url: String!
+ *   }
+ *
+ *   type Video {
+ *     url: String!
+ *   }
+ *
+ *   union Media = Photo | Video
+ *
+ *   type Query {
+ *     media: [Media]
+ *   }
+ * `);
+ *
+ * isUnionType(schema.getType('Media')); // => true
+ * isUnionType(schema.getType('Photo')); // => false
+ * ```
+ */
+export declare function isUnionType(type: unknown): type is GraphQLUnionType;
+/**
+ * Returns the value as a GraphQLUnionType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLUnionType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertUnionType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Photo {
+ *     url: String!
+ *   }
+ *
+ *   type Video {
+ *     url: String!
+ *   }
+ *
+ *   union Media = Photo | Video
+ *
+ *   type Query {
+ *     media: [Media]
+ *   }
+ * `);
+ *
+ * const mediaType = assertUnionType(schema.getType('Media'));
+ *
+ * mediaType.getTypes().map((type) => type.name); // => ['Photo', 'Video']
+ * assertUnionType(schema.getType('Photo')); // throws an error
+ * ```
+ */
+export declare function assertUnionType(type: unknown): GraphQLUnionType;
+/**
+ * Returns true when the value is a GraphQLEnumType.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLEnumType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isEnumType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ *
+ *   type Query {
+ *     favoriteEpisode: Episode
+ *   }
+ * `);
+ *
+ * isEnumType(schema.getType('Episode')); // => true
+ * isEnumType(schema.getType('Query')); // => false
+ * ```
+ */
+export declare function isEnumType(type: unknown): type is GraphQLEnumType;
+/**
+ * Returns the value as a GraphQLEnumType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLEnumType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertEnumType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ *
+ *   type Query {
+ *     favoriteEpisode: Episode
+ *   }
+ * `);
+ *
+ * const episodeType = assertEnumType(schema.getType('Episode'));
+ *
+ * episodeType.getValues().map((value) => value.name); // => ['NEW_HOPE', 'EMPIRE']
+ * assertEnumType(schema.getType('Query')); // throws an error
+ * ```
+ */
+export declare function assertEnumType(type: unknown): GraphQLEnumType;
+/**
+ * Returns true when the value is a resolved GraphQL enum value definition.
+ * @param value - Value to inspect.
+ * @returns True when the value is a GraphQLEnumValue.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertEnumType, isEnumValue } from 'graphql/type';
+ *
+ * const schema = buildSchema(
+ *   'enum Episode { NEW_HOPE } type Query { episode: Episode }',
+ * );
+ * const enumValue = assertEnumType(schema.getType('Episode')).getValues()[0];
+ *
+ * isEnumValue(enumValue); // => true
+ * isEnumValue(schema.getType('Episode')); // => false
+ * ```
+ */
+export declare function isEnumValue(value: unknown): value is GraphQLEnumValue;
+/**
+ * Returns the value as a GraphQLEnumValue, or throws if it is not one.
+ * @param value - Value to inspect.
+ * @returns The value typed as a GraphQLEnumValue.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertEnumType, assertEnumValue } from 'graphql/type';
+ *
+ * const schema = buildSchema(
+ *   'enum Episode { NEW_HOPE } type Query { episode: Episode }',
+ * );
+ * const enumValue = assertEnumValue(
+ *   assertEnumType(schema.getType('Episode')).getValues()[0],
+ * );
+ *
+ * enumValue.name; // => 'NEW_HOPE'
+ * assertEnumValue(schema.getType('Episode')); // throws an error
+ * ```
+ */
+export declare function assertEnumValue(value: unknown): GraphQLEnumValue;
+/**
+ * Returns true when the value is a GraphQLInputObjectType.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLInputObjectType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isInputObjectType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * isInputObjectType(schema.getType('ReviewInput')); // => true
+ * isInputObjectType(schema.getType('Review')); // => false
+ * ```
+ */
+export declare function isInputObjectType(type: unknown): type is GraphQLInputObjectType;
+/**
+ * Returns the value as a GraphQLInputObjectType, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLInputObjectType.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertInputObjectType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * const inputType = assertInputObjectType(schema.getType('ReviewInput'));
+ *
+ * Object.keys(inputType.getFields()); // => ['stars']
+ * assertInputObjectType(schema.getType('Review')); // throws an error
+ * ```
+ */
+export declare function assertInputObjectType(type: unknown): GraphQLInputObjectType;
+/**
+ * Returns true when the value is a resolved GraphQL input field definition.
+ * @param field - Value to inspect.
+ * @returns True when the value is a GraphQLInputField.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertInputObjectType, isInputField } from 'graphql/type';
+ *
+ * const schema = buildSchema(
+ *   'input ReviewInput { stars: Int } type Query { ok: Boolean }',
+ * );
+ * const inputField = assertInputObjectType(
+ *   schema.getType('ReviewInput'),
+ * ).getFields().stars;
+ *
+ * isInputField(inputField); // => true
+ * isInputField(schema.getQueryType()); // => false
+ * ```
+ */
+export declare function isInputField(field: unknown): field is GraphQLInputField;
+/**
+ * Returns the value as a GraphQLInputField, or throws if it is not one.
+ * @param field - Value to inspect.
+ * @returns The value typed as a GraphQLInputField.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertInputField, assertInputObjectType } from 'graphql/type';
+ *
+ * const schema = buildSchema(
+ *   'input ReviewInput { stars: Int } type Query { ok: Boolean }',
+ * );
+ * const inputField = assertInputField(
+ *   assertInputObjectType(schema.getType('ReviewInput')).getFields().stars,
+ * );
+ *
+ * inputField.name; // => 'stars'
+ * assertInputField(schema.getQueryType()); // throws an error
+ * ```
+ */
+export declare function assertInputField(field: unknown): GraphQLInputField;
+/**
+ * Returns true when the value is a GraphQLList.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLList.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { GraphQLList, GraphQLString, isListType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     tags: [String!]!
+ *   }
+ * `);
+ *
+ * const tagsField = schema.getQueryType()?.getFields().tags;
+ *
+ * isListType(new GraphQLList(GraphQLString)); // => true
+ * isListType(GraphQLString); // => false
+ * isListType(tagsField?.type); // => false
+ * ```
+ */
+export declare function isListType(type: GraphQLInputType): type is GraphQLList<GraphQLInputType>;
+/**
+ * Returns true when the output type is a GraphQLList.
+ * @param type - The GraphQL output type to inspect.
+ * @returns True when the output type is a list type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getNullableType, isListType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     tags: [String!]!
+ *   }
+ * `);
+ *
+ * const tagsField = schema.getQueryType()?.getFields().tags;
+ * const nullableTagsType = getNullableType(tagsField?.type);
+ *
+ * isListType(nullableTagsType); // => true
+ * ```
+ */
+export declare function isListType(type: GraphQLOutputType): type is GraphQLList<GraphQLOutputType>;
+/**
+ * Returns true when the value is a GraphQLList.
+ * @param type - The value to inspect.
+ * @returns True when the value is a list type.
+ * @example
+ * ```ts
+ * import { isListType } from 'graphql/type';
+ *
+ * isListType('[String]'); // => false
+ * isListType(null); // => false
+ * ```
+ */
+export declare function isListType(type: unknown): type is GraphQLList<GraphQLType>;
+/**
+ * Returns the value as a GraphQLList, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLList.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLString, assertListType } from 'graphql/type';
+ *
+ * const listType = assertListType(new GraphQLList(GraphQLString));
+ *
+ * listType.ofType; // => GraphQLString
+ * assertListType(GraphQLString); // throws an error
+ * ```
+ */
+export declare function assertListType(type: unknown): GraphQLList<GraphQLType>;
+/**
+ * Returns true when the value is a GraphQLNonNull.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQLNonNull.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { GraphQLNonNull, GraphQLString, isNonNullType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String!
+ *     nickname: String
+ *   }
+ * `);
+ *
+ * const fields = schema.getQueryType()?.getFields();
+ *
+ * isNonNullType(new GraphQLNonNull(GraphQLString)); // => true
+ * isNonNullType(fields?.name.type); // => true
+ * isNonNullType(fields?.nickname.type); // => false
+ * ```
+ */
+export declare function isNonNullType(type: GraphQLInputType): type is GraphQLNonNull<GraphQLNullableInputType>;
+/**
+ * Returns true when the output type is a GraphQLNonNull.
+ * @param type - The GraphQL output type to inspect.
+ * @returns True when the output type is a non-null type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isNonNullType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String!
+ *     nickname: String
+ *   }
+ * `);
+ *
+ * const fields = schema.getQueryType()?.getFields();
+ *
+ * isNonNullType(fields?.name.type); // => true
+ * isNonNullType(fields?.nickname.type); // => false
+ * ```
+ */
+export declare function isNonNullType(type: GraphQLOutputType): type is GraphQLNonNull<GraphQLNullableOutputType>;
+/**
+ * Returns true when the value is a GraphQLNonNull.
+ * @param type - The value to inspect.
+ * @returns True when the value is a non-null type.
+ * @example
+ * ```ts
+ * import { isNonNullType } from 'graphql/type';
+ *
+ * isNonNullType('String!'); // => false
+ * isNonNullType(null); // => false
+ * ```
+ */
+export declare function isNonNullType(type: unknown): type is GraphQLNonNull<GraphQLNullableType>;
+/**
+ * Returns the value as a GraphQLNonNull, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQLNonNull.
+ * @example
+ * ```ts
+ * import { GraphQLNonNull, GraphQLString, assertNonNullType } from 'graphql/type';
+ *
+ * const nonNullType = assertNonNullType(new GraphQLNonNull(GraphQLString));
+ *
+ * nonNullType.ofType; // => GraphQLString
+ * assertNonNullType(GraphQLString); // throws an error
+ * ```
+ */
+export declare function assertNonNullType(type: unknown): GraphQLNonNull<GraphQLNullableType>;
+/** These types may be used as input types for arguments and directives. */
+export type GraphQLNullableInputType = GraphQLNamedInputType | GraphQLList<GraphQLInputType>;
+/** These types may be used as input types for arguments and directives. */
+export type GraphQLInputType = GraphQLNullableInputType | GraphQLNonNull<GraphQLNullableInputType>;
+/**
+ * Returns true when the value can be used as a GraphQL input type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value can be used as a GraphQL input type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isInputType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * isInputType(schema.getType('ReviewInput')); // => true
+ * isInputType(schema.getType('Review')); // => false
+ * ```
+ */
+export declare function isInputType(type: unknown): type is GraphQLInputType;
+/**
+ * Returns the value as a GraphQL input type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL input type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertInputType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * const inputType = assertInputType(schema.getType('ReviewInput'));
+ *
+ * inputType.toString(); // => 'ReviewInput'
+ * assertInputType(schema.getType('Review')); // throws an error
+ * ```
+ */
+export declare function assertInputType(type: unknown): GraphQLInputType;
+/** These types may be used as output types as the result of fields. */
+export type GraphQLNullableOutputType = GraphQLNamedOutputType | GraphQLList<GraphQLOutputType>;
+/** These types may be used as output types as the result of fields. */
+export type GraphQLOutputType = GraphQLNullableOutputType | GraphQLNonNull<GraphQLNullableOutputType>;
+/**
+ * Returns true when the value can be used as a GraphQL output type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value can be used as a GraphQL output type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isOutputType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * isOutputType(schema.getType('Review')); // => true
+ * isOutputType(schema.getType('ReviewInput')); // => false
+ * ```
+ */
+export declare function isOutputType(type: unknown): type is GraphQLOutputType;
+/**
+ * Returns the value as a GraphQL output type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL output type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertOutputType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput): Review
+ *   }
+ * `);
+ *
+ * const outputType = assertOutputType(schema.getType('Review'));
+ *
+ * outputType.toString(); // => 'Review'
+ * assertOutputType(schema.getType('ReviewInput')); // throws an error
+ * ```
+ */
+export declare function assertOutputType(type: unknown): GraphQLOutputType;
+/** These types may describe types which may be leaf values. */
+export type GraphQLLeafType = GraphQLScalarType | GraphQLEnumType;
+/**
+ * Returns true when the value is a GraphQL scalar or enum type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL scalar or enum type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isLeafType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     episode: Episode
+ *     review: Review
+ *   }
+ * `);
+ *
+ * isLeafType(schema.getType('Episode')); // => true
+ * isLeafType(schema.getType('String')); // => true
+ * isLeafType(schema.getType('Review')); // => false
+ * ```
+ */
+export declare function isLeafType(type: unknown): type is GraphQLLeafType;
+/**
+ * Returns the value as a GraphQL leaf type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL leaf type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertLeafType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *   }
+ *
+ *   type Review {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     episode: Episode
+ *     review: Review
+ *   }
+ * `);
+ *
+ * const episodeType = assertLeafType(schema.getType('Episode'));
+ *
+ * episodeType.toString(); // => 'Episode'
+ * assertLeafType(schema.getType('Review')); // throws an error
+ * ```
+ */
+export declare function assertLeafType(type: unknown): GraphQLLeafType;
+/** These types may describe the parent context of a selection set. */
+export type GraphQLCompositeType = GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType;
+/**
+ * Returns true when the value is a GraphQL object, interface, or union type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL object, interface, or union type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isCompositeType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   union SearchResult = User
+ *
+ *   type Query {
+ *     node: Node
+ *     search: [SearchResult]
+ *   }
+ * `);
+ *
+ * isCompositeType(schema.getType('User')); // => true
+ * isCompositeType(schema.getType('Node')); // => true
+ * isCompositeType(schema.getType('SearchResult')); // => true
+ * isCompositeType(schema.getType('String')); // => false
+ * ```
+ */
+export declare function isCompositeType(type: unknown): type is GraphQLCompositeType;
+/**
+ * Returns the value as a GraphQL composite type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL composite type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertCompositeType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ *
+ * const userType = assertCompositeType(schema.getType('User'));
+ *
+ * userType.toString(); // => 'User'
+ * assertCompositeType(schema.getType('String')); // throws an error
+ * ```
+ */
+export declare function assertCompositeType(type: unknown): GraphQLCompositeType;
+/** These types may describe the parent context of a selection set. */
+export type GraphQLAbstractType = GraphQLInterfaceType | GraphQLUnionType;
+/**
+ * Returns true when the value is a GraphQL interface or union type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL interface or union type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { isAbstractType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   union SearchResult = User
+ *
+ *   type Query {
+ *     node: Node
+ *     search: [SearchResult]
+ *   }
+ * `);
+ *
+ * isAbstractType(schema.getType('Node')); // => true
+ * isAbstractType(schema.getType('SearchResult')); // => true
+ * isAbstractType(schema.getType('User')); // => false
+ * ```
+ */
+export declare function isAbstractType(type: unknown): type is GraphQLAbstractType;
+/**
+ * Returns the value as a GraphQL abstract type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL abstract type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertAbstractType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ *
+ * const nodeType = assertAbstractType(schema.getType('Node'));
+ *
+ * nodeType.toString(); // => 'Node'
+ * assertAbstractType(schema.getType('User')); // throws an error
+ * ```
+ */
+export declare function assertAbstractType(type: unknown): GraphQLAbstractType;
+/**
+ * List Type Wrapper
+ *
+ * A list is a wrapping type which points to another type.
+ * Lists are often created within the context of defining the fields of
+ * an object type.
+ * @typeParam T - The GraphQL type wrapped by this list type.
+ * @example
+ * ```ts
+ * const PersonType = new GraphQLObjectType({
+ *   name: 'Person',
+ *   fields: () => ({
+ *     parents: { type: new GraphQLList(PersonType) },
+ *     children: { type: new GraphQLList(PersonType) },
+ *   }),
+ * });
+ * ```
+ */
+export declare class GraphQLList<T extends GraphQLType> implements GraphQLSchemaElement {
+	/** The type wrapped by this list or non-null type. */
+	readonly ofType: T;
+	private readonly __GraphQLListTypeBrand;
+	/**
+	 * Creates a GraphQLList instance.
+	 * @param ofType - The type to wrap.
+	 * @example
+	 * ```ts
+	 * import { GraphQLList, GraphQLString } from 'graphql/type';
+	 *
+	 * const stringList = new GraphQLList(GraphQLString);
+	 *
+	 * stringList.ofType; // => GraphQLString
+	 * String(stringList); // => '[String]'
+	 * ```
+	 */
+	constructor(ofType: T);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns this wrapping type as a GraphQL type-reference string.
+	 * @returns The GraphQL type-reference string.
+	 * @example
+	 * ```ts
+	 * import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';
+	 *
+	 * const stringList = new GraphQLList(GraphQLString);
+	 * const requiredStringList = new GraphQLList(new GraphQLNonNull(GraphQLString));
+	 *
+	 * stringList.toString(); // => '[String]'
+	 * requiredStringList.toString(); // => '[String!]'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLList, GraphQLString } from 'graphql/type';
+	 *
+	 * const stringList = new GraphQLList(GraphQLString);
+	 *
+	 * stringList.toJSON(); // => '[String]'
+	 * JSON.stringify({ type: stringList }); // => '{"type":"[String]"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Non-Null Type Wrapper
+ *
+ * A non-null is a wrapping type which points to another type.
+ * Non-null types enforce that their values are never null and can ensure
+ * an error is raised if this ever occurs during a request. It is useful for
+ * fields which you can make a strong guarantee on non-nullability, for example
+ * usually the id field of a database row will never be null.
+ * @typeParam T - The nullable GraphQL type wrapped by this non-null type.
+ * @example
+ * ```ts
+ * const RowType = new GraphQLObjectType({
+ *   name: 'Row',
+ *   fields: () => ({
+ *     id: { type: new GraphQLNonNull(GraphQLString) },
+ *   }),
+ * });
+ * ```
+ *
+ * Note: the enforcement of non-nullability occurs within the executor.
+ */
+export declare class GraphQLNonNull<T extends GraphQLNullableType> implements GraphQLSchemaElement {
+	/** The type wrapped by this list or non-null type. */
+	readonly ofType: T;
+	private readonly __GraphQLNonNullTypeBrand;
+	/**
+	 * Creates a GraphQLNonNull instance.
+	 * @param ofType - The type to wrap.
+	 * @example
+	 * ```ts
+	 * import { GraphQLNonNull, GraphQLString } from 'graphql/type';
+	 *
+	 * const requiredString = new GraphQLNonNull(GraphQLString);
+	 *
+	 * requiredString.ofType; // => GraphQLString
+	 * String(requiredString); // => 'String!'
+	 * ```
+	 */
+	constructor(ofType: T);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns this wrapping type as a GraphQL type-reference string.
+	 * @returns The GraphQL type-reference string.
+	 * @example
+	 * ```ts
+	 * import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';
+	 *
+	 * const requiredString = new GraphQLNonNull(GraphQLString);
+	 * const requiredStringList = new GraphQLNonNull(new GraphQLList(GraphQLString));
+	 *
+	 * requiredString.toString(); // => 'String!'
+	 * requiredStringList.toString(); // => '[String]!'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLNonNull, GraphQLString } from 'graphql/type';
+	 *
+	 * const requiredString = new GraphQLNonNull(GraphQLString);
+	 *
+	 * requiredString.toJSON(); // => 'String!'
+	 * JSON.stringify({ type: requiredString }); // => '{"type":"String!"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/** These types wrap and modify other types */
+export type GraphQLWrappingType = GraphQLList<GraphQLType> | GraphQLNonNull<GraphQLNullableType>;
+/**
+ * Returns true when the value is a GraphQL list or non-null wrapper type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL list or non-null wrapper type.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   isWrappingType,
+ * } from 'graphql/type';
+ *
+ * isWrappingType(new GraphQLList(GraphQLString)); // => true
+ * isWrappingType(new GraphQLNonNull(GraphQLString)); // => true
+ * isWrappingType(GraphQLString); // => false
+ * ```
+ */
+export declare function isWrappingType(type: unknown): type is GraphQLWrappingType;
+/**
+ * Returns the value as a GraphQL wrapping type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL wrapping type.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLString, assertWrappingType } from 'graphql/type';
+ *
+ * const wrappingType = assertWrappingType(new GraphQLList(GraphQLString));
+ *
+ * wrappingType.toString(); // => '[String]'
+ * assertWrappingType(GraphQLString); // throws an error
+ * ```
+ */
+export declare function assertWrappingType(type: unknown): GraphQLWrappingType;
+/** These types can all accept null as a value. */
+export type GraphQLNullableType = GraphQLNamedType | GraphQLList<GraphQLType>;
+/**
+ * Returns true when the value is a GraphQL type that can accept null.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL type that can accept null.
+ * @example
+ * ```ts
+ * import { GraphQLNonNull, GraphQLString, isNullableType } from 'graphql/type';
+ *
+ * isNullableType(GraphQLString); // => true
+ * isNullableType(new GraphQLNonNull(GraphQLString)); // => false
+ * isNullableType(null); // => false
+ * ```
+ */
+export declare function isNullableType(type: unknown): type is GraphQLNullableType;
+/**
+ * Returns the value as a nullable GraphQL type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a nullable GraphQL type.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   assertNullableType,
+ * } from 'graphql/type';
+ *
+ * const nullableType = assertNullableType(GraphQLString);
+ *
+ * nullableType; // => GraphQLString
+ * assertNullableType(new GraphQLNonNull(GraphQLString)); // throws an error
+ * ```
+ */
+export declare function assertNullableType(type: unknown): GraphQLNullableType;
+/**
+ * Returns the nullable type.
+ * @param type - The GraphQL type to inspect.
+ * @returns The nullable type after removing one non-null wrapper, if present.
+ * @example
+ * ```ts
+ * import { getNullableType } from 'graphql/type';
+ *
+ * getNullableType(null); // => undefined
+ * getNullableType(undefined); // => undefined
+ * ```
+ */
+export declare function getNullableType(type: undefined | null): void;
+/**
+ * Returns the nullable type after removing one non-null wrapper.
+ * @param type - A nullable type or non-null wrapper.
+ * @returns The nullable type after removing one non-null wrapper, if present.
+ * @typeParam T - The nullable GraphQL type returned after removing one non-null wrapper.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   getNullableType,
+ * } from 'graphql/type';
+ *
+ * const requiredString = new GraphQLNonNull(GraphQLString);
+ * const stringList = new GraphQLList(GraphQLString);
+ *
+ * getNullableType(requiredString); // => GraphQLString
+ * getNullableType(stringList); // => stringList
+ * ```
+ */
+export declare function getNullableType<T extends GraphQLNullableType>(type: T | GraphQLNonNull<T>): T;
+/**
+ * Returns the nullable type after removing one non-null wrapper.
+ * @param type - The GraphQL type to inspect.
+ * @returns The nullable type after removing one non-null wrapper, if present.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   getNullableType,
+ * } from 'graphql/type';
+ *
+ * const requiredStringList = new GraphQLNonNull(new GraphQLList(GraphQLString));
+ *
+ * getNullableType(requiredStringList).toString(); // => '[String]'
+ * getNullableType(GraphQLString); // => GraphQLString
+ * ```
+ */
+export declare function getNullableType(type: Maybe<GraphQLType>): GraphQLNullableType | undefined;
+/** These named types do not include modifiers like List or NonNull. */
+export type GraphQLNamedType = GraphQLNamedInputType | GraphQLNamedOutputType;
+/** A named GraphQL type that can be used as an input type. */
+export type GraphQLNamedInputType = GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType;
+/** A named GraphQL type that can be used as an output type. */
+export type GraphQLNamedOutputType = GraphQLScalarType | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | GraphQLEnumType;
+/**
+ * Returns true when the value is a GraphQL named type.
+ * @param type - The GraphQL type to inspect.
+ * @returns True when the value is a GraphQL named type.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLString, isNamedType } from 'graphql/type';
+ *
+ * isNamedType(GraphQLString); // => true
+ * isNamedType(new GraphQLList(GraphQLString)); // => false
+ * isNamedType(null); // => false
+ * ```
+ */
+export declare function isNamedType(type: unknown): type is GraphQLNamedType;
+/**
+ * Returns the value as a GraphQL named type, or throws if it is not one.
+ * @param type - The GraphQL type to inspect.
+ * @returns The value typed as a GraphQL named type.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLString, assertNamedType } from 'graphql/type';
+ *
+ * const namedType = assertNamedType(GraphQLString);
+ *
+ * namedType.name; // => 'String'
+ * assertNamedType(new GraphQLList(GraphQLString)); // throws an error
+ * ```
+ */
+export declare function assertNamedType(type: unknown): GraphQLNamedType;
+/**
+ * Returns the named type.
+ * @param type - The GraphQL type to inspect.
+ * @returns The named type after unwrapping all list and non-null wrappers.
+ * @example
+ * ```ts
+ * import { getNamedType } from 'graphql/type';
+ *
+ * getNamedType(null); // => undefined
+ * getNamedType(undefined); // => undefined
+ * ```
+ */
+export declare function getNamedType(type: undefined | null): void;
+/**
+ * Returns the named input type after unwrapping all list and non-null wrappers.
+ * @param type - The GraphQL input type to inspect.
+ * @returns The named input type after unwrapping all wrappers.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getNamedType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: [ReviewInput!]!): Boolean
+ *   }
+ * `);
+ *
+ * const inputArg = schema.getQueryType()?.getFields().review.args[0];
+ *
+ * getNamedType(inputArg?.type).toString(); // => 'ReviewInput'
+ * ```
+ */
+export declare function getNamedType(type: GraphQLInputType): GraphQLNamedInputType;
+/**
+ * Returns the named output type after unwrapping all list and non-null wrappers.
+ * @param type - The GraphQL output type to inspect.
+ * @returns The named output type after unwrapping all wrappers.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getNamedType } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     users: [User!]!
+ *   }
+ * `);
+ *
+ * const usersField = schema.getQueryType()?.getFields().users;
+ *
+ * getNamedType(usersField?.type).toString(); // => 'User'
+ * ```
+ */
+export declare function getNamedType(type: GraphQLOutputType): GraphQLNamedOutputType;
+/**
+ * Returns the named type after unwrapping all list and non-null wrappers.
+ * @param type - The GraphQL type to inspect.
+ * @returns The named type after unwrapping all wrappers.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   getNamedType,
+ * } from 'graphql/type';
+ *
+ * const nestedType = new GraphQLNonNull(
+ *   new GraphQLList(new GraphQLNonNull(GraphQLString)),
+ * );
+ *
+ * getNamedType(nestedType); // => GraphQLString
+ * ```
+ */
+export declare function getNamedType(type: GraphQLType): GraphQLNamedType;
+/**
+ * Returns the named type after unwrapping all list and non-null wrappers.
+ * @param type - The GraphQL type to inspect.
+ * @returns The named type after unwrapping all wrappers, or undefined for nullish input.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLString, getNamedType } from 'graphql/type';
+ *
+ * getNamedType(new GraphQLList(GraphQLString)); // => GraphQLString
+ * getNamedType(undefined); // => undefined
+ * ```
+ */
+export declare function getNamedType(type: Maybe<GraphQLType>): GraphQLNamedType | undefined;
+interface GraphQLSchemaElement {
+	toString: () => string;
+	toJSON: () => string;
+}
+/**
+ * Used while defining GraphQL types to allow for circular references in
+ * otherwise immutable type definitions.
+ * @typeParam T - The element type returned by the thunk or array.
+ */
+export type ThunkReadonlyArray<T> = (() => ReadonlyArray<T>) | ReadonlyArray<T>;
+/**
+ * A thunk that resolves to an object map.
+ * @typeParam T - Value type stored in the object map.
+ */
+export type ThunkObjMap<T> = (() => ObjMap<T>) | ObjMap<T>;
+/**
+ * Resolves a thunked readonly array.
+ * @param thunk - The thunk or value to resolve.
+ * @returns The resolved readonly array.
+ * @typeParam T - The element type resolved from the thunk or array.
+ * @example
+ * ```ts
+ * import { GraphQLString, resolveReadonlyArrayThunk } from 'graphql/type';
+ *
+ * const lazyFields = resolveReadonlyArrayThunk(() => [GraphQLString]);
+ * const fields = resolveReadonlyArrayThunk([GraphQLString]);
+ *
+ * lazyFields; // => [GraphQLString]
+ * fields; // => [GraphQLString]
+ * ```
+ */
+export declare function resolveReadonlyArrayThunk<T>(thunk: ThunkReadonlyArray<T>): ReadonlyArray<T>;
+/**
+ * Resolves a thunked object map.
+ * @param thunk - The thunk or value to resolve.
+ * @returns The resolved object map.
+ * @typeParam T - The object-map value type resolved from the thunk or map.
+ * @example
+ * ```ts
+ * import { GraphQLString, resolveObjMapThunk } from 'graphql/type';
+ *
+ * const lazyFields = resolveObjMapThunk(() => ({ name: GraphQLString }));
+ * const fields = resolveObjMapThunk({ name: GraphQLString });
+ *
+ * lazyFields.name; // => GraphQLString
+ * fields.name; // => GraphQLString
+ * ```
+ */
+export declare function resolveObjMapThunk<T>(thunk: ThunkObjMap<T>): ObjMap<T>;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLScalarTypeExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Scalar Type Definition
+ *
+ * Scalar types define the leaf values of a GraphQL response and the input
+ * values accepted by arguments and input object fields. A scalar type has a
+ * name and coercion functions that validate and convert runtime values and
+ * GraphQL literals.
+ *
+ * If a type's coerceOutputValue function returns `null` or does not return a
+ * value (i.e. it returns `undefined`) then an error will be raised and a
+ * `null` value will be returned in the response. Prefer validating inputs
+ * before execution so clients receive input diagnostics before result coercion
+ * fails.
+ * Custom scalar behavior is defined via the following functions:
+ *
+ *  - coerceOutputValue(value): Implements "Result Coercion". Given an internal value,
+ *    produces an external value valid for this type. Returns undefined or
+ *    throws an error to indicate invalid values.
+ *
+ *  - coerceInputValue(value): Implements "Input Coercion" for values. Given an
+ *    external value (for example, variable values), produces an internal value
+ *    valid for this type. Returns undefined or throws an error to indicate
+ *    invalid values.
+ *
+ *  - coerceInputLiteral(ast): Implements "Input Coercion" for constant literals.
+ *    Given a GraphQL literal (AST) (for example, an argument value), produces
+ *    an internal value valid for this type. Returns undefined or throws an
+ *    error to indicate invalid values.
+ *
+ *  - valueToLiteral(value): Converts an external value to a GraphQL
+ *    literal (AST). Returns undefined or throws an error to indicate
+ *    invalid values.
+ *
+ *  Deprecated, to be removed in v18:
+ *
+ *  - serialize(value): Implements "Result Coercion". Renamed to
+ *    `coerceOutputValue()`.
+ *
+ *  - parseValue(value): Implements "Input Coercion" for values. Renamed to
+ *    `coerceInputValue()`.
+ *
+ *  - parseLiteral(ast): Implements "Input Coercion" for literals including
+ *    non-specified replacement of variables embedded within complex scalars.
+ *    Replaced by the combination of the `replaceVariables()` utility and the
+ *    `coerceInputLiteral()` method.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ * @typeParam TExternal - External representation accepted from or returned to callers.
+ * @example
+ * ```ts
+ * import { GraphQLScalarType, Kind } from 'graphql';
+ *
+ * const ensureOdd = (value) => {
+ *   if (!Number.isFinite(value)) {
+ *     throw new Error(
+ *       `Scalar "Odd" cannot represent "${value}" since it is not a finite number.`,
+ *     );
+ *   }
+ *
+ *   if (value % 2 === 0) {
+ *     throw new Error(
+ *       `Scalar "Odd" cannot represent "${value}" since it is even.`,
+ *     );
+ *   }
+ *
+ *   return value;
+ * };
+ *
+ * const OddType = new GraphQLScalarType({
+ *   name: 'Odd',
+ *   coerceOutputValue: (value) => {
+ *     return ensureOdd(value);
+ *   },
+ *   coerceInputValue: (value) => {
+ *     return ensureOdd(value);
+ *   },
+ *   valueToLiteral: (value) => {
+ *     return { kind: Kind.INT, value: String(ensureOdd(value)) };
+ *   },
+ * });
+ * ```
+ */
+export declare class GraphQLScalarType<TInternal = unknown, TExternal = TInternal> implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** URL identifying the behavior specified for this custom scalar. */
+	specifiedByURL: Maybe<string>;
+	/**
+	 * Deprecated legacy serializer used to convert internal values for response
+	 * output. Use `coerceOutputValue()` instead.
+	 * @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18
+	 */
+	serialize: GraphQLScalarSerializer<TExternal>;
+	/**
+	 * Deprecated legacy parser used to convert externally provided input values.
+	 * Use `coerceInputValue()` instead.
+	 * @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18
+	 */
+	parseValue: GraphQLScalarValueParser<TInternal>;
+	/**
+	 * Deprecated legacy parser used to convert externally provided input
+	 * literals. Use `replaceVariables()` and `coerceInputLiteral()` instead.
+	 * @deprecated use `replaceVariables()` and `coerceInputLiteral()` instead, `parseLiteral()` will be removed in v18
+	 */
+	parseLiteral: GraphQLScalarLiteralParser<TInternal>;
+	/** Coercer used to convert internal scalar values for response output. */
+	coerceOutputValue: GraphQLScalarOutputValueCoercer<TExternal>;
+	/** Coercer used to convert externally provided scalar input values. */
+	coerceInputValue: GraphQLScalarInputValueCoercer<TInternal>;
+	/** Coercer used to convert GraphQL scalar input literals. */
+	coerceInputLiteral: GraphQLScalarInputLiteralCoercer<TInternal> | undefined;
+	/** Converter used to produce GraphQL literals from runtime input values. */
+	valueToLiteral: GraphQLScalarValueToLiteral | undefined;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLScalarTypeExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<ScalarTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
+	/**
+	 * Creates a GraphQLScalarType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { Kind, parse } from 'graphql/language';
+	 * import { GraphQLScalarType } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   "Odd integer values."
+	 *   scalar Odd @specifiedBy(url: "https://example.com/odd")
+	 *
+	 *   extend scalar Odd @specifiedBy(url: "https://example.com/odd-v2")
+	 * `);
+	 *
+	 * const Odd = new GraphQLScalarType({
+	 *   name: 'Odd',
+	 *   description: 'Odd integer values.',
+	 *   specifiedByURL: 'https://example.com/odd',
+	 *   coerceOutputValue: (value) => {
+	 *     if (typeof value !== 'number' || value % 2 === 0) {
+	 *       throw new TypeError('Odd can only produce odd numbers.');
+	 *     }
+	 *     return value;
+	 *   },
+	 *   coerceInputValue: (value) => {
+	 *     if (typeof value !== 'number' || value % 2 === 0) {
+	 *       throw new TypeError('Odd can only accept odd numbers.');
+	 *     }
+	 *     return value;
+	 *   },
+	 *   coerceInputLiteral: (ast) => {
+	 *     if (ast.kind !== Kind.INT) {
+	 *       throw new TypeError('Odd can only accept integer literals.');
+	 *     }
+	 *     const value = Number(ast.value);
+	 *     if (value % 2 === 0) {
+	 *       throw new TypeError('Odd can only accept odd integer literals.');
+	 *     }
+	 *     return value;
+	 *   },
+	 *   valueToLiteral: (value) => {
+	 *     return { kind: Kind.INT, value: String(ensureOdd(value)) };
+	 *   },
+	 *   extensions: { numeric: true },
+	 *   astNode: document.definitions[0],
+	 *   extensionASTNodes: [document.definitions[1]],
+	 * });
+	 *
+	 * Odd.description; // => 'Odd integer values.'
+	 * Odd.specifiedByURL; // => 'https://example.com/odd'
+	 * Odd.coerceOutputValue(3); // => 3
+	 * Odd.coerceInputValue(5); // => 5
+	 * Odd.extensions; // => { numeric: true }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLScalarTypeConfig<TInternal, TExternal>>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { GraphQLScalarType } from 'graphql/type';
+	 *
+	 * const Url = new GraphQLScalarType({
+	 *   name: 'Url',
+	 *   description: 'An absolute URL string.',
+	 *   specifiedByURL: 'https://url.spec.whatwg.org/',
+	 * });
+	 *
+	 * const config = Url.toConfig();
+	 * const UrlCopy = new GraphQLScalarType(config);
+	 *
+	 * config.name; // => 'Url'
+	 * config.specifiedByURL; // => 'https://url.spec.whatwg.org/'
+	 * UrlCopy.name; // => Url.name
+	 * ```
+	 */
+	toConfig(): GraphQLScalarTypeNormalizedConfig<TInternal, TExternal>;
+	/**
+	 * Returns the schema coordinate identifying this scalar type.
+	 * @returns The schema coordinate for this scalar type.
+	 * @example
+	 * ```ts
+	 * import { GraphQLScalarType } from 'graphql/type';
+	 *
+	 * const DateTime = new GraphQLScalarType({ name: 'DateTime' });
+	 *
+	 * DateTime.toString(); // => 'DateTime'
+	 * String(DateTime); // => 'DateTime'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLScalarType } from 'graphql/type';
+	 *
+	 * const DateTime = new GraphQLScalarType({ name: 'DateTime' });
+	 *
+	 * DateTime.toJSON(); // => 'DateTime'
+	 * JSON.stringify({ type: DateTime }); // => '{"type":"DateTime"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Deprecated function type that serializes a runtime value as a scalar output
+ * value. Use `GraphQLScalarOutputValueCoercer` instead.
+ * @typeParam TExternal - External representation accepted from or returned to callers.
+ * @deprecated Use GraphQLScalarOutputValueCoercer instead. Will be removed in v18.
+ */
+export type GraphQLScalarSerializer<TExternal> = (outputValue: unknown) => TExternal;
+/**
+ * Function used to coerce internal scalar values for response output.
+ * @typeParam TExternal - External representation accepted from or returned to callers.
+ */
+export type GraphQLScalarOutputValueCoercer<TExternal> = (outputValue: unknown) => TExternal;
+/**
+ * Deprecated function type that parses a runtime input value as a scalar input
+ * value. Use `GraphQLScalarInputValueCoercer` instead.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ * @deprecated Use GraphQLScalarInputValueCoercer instead. Will be removed in v18.
+ */
+export type GraphQLScalarValueParser<TInternal> = (inputValue: unknown) => TInternal;
+/**
+ * Function used to coerce externally provided scalar input values.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ */
+export type GraphQLScalarInputValueCoercer<TInternal> = (inputValue: unknown) => TInternal;
+/**
+ * Deprecated function type that parses a GraphQL value literal as a scalar
+ * input value. Use `GraphQLScalarInputLiteralCoercer` instead.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ * @deprecated Use GraphQLScalarInputLiteralCoercer instead. Will be removed in v18.
+ */
+export type GraphQLScalarLiteralParser<TInternal> = (valueNode: ValueNode, variables: Maybe<ObjMap<unknown>>) => Maybe<TInternal>;
+/**
+ * Function used to coerce GraphQL scalar input literals.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ */
+export type GraphQLScalarInputLiteralCoercer<TInternal> = (valueNode: ConstValueNode) => Maybe<TInternal>;
+type GraphQLScalarValueToLiteral = (inputValue: unknown) => ConstValueNode | undefined;
+/**
+ * Configuration used to construct a GraphQLScalarType.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ * @typeParam TExternal - External representation accepted from or returned to callers.
+ */
+export interface GraphQLScalarTypeConfig<TInternal, TExternal> {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** URL identifying the behavior specified for this custom scalar. */
+	specifiedByURL?: Maybe<string>;
+	/**
+	 * Deprecated legacy serializer used to convert internal values for response
+	 * output. Use `coerceOutputValue()` instead.
+	 * @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18
+	 */
+	serialize?: GraphQLScalarSerializer<TExternal> | undefined;
+	/**
+	 * Deprecated legacy parser used to convert externally provided input values.
+	 * Use `coerceInputValue()` instead.
+	 * @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18
+	 */
+	parseValue?: GraphQLScalarValueParser<TInternal> | undefined;
+	/**
+	 * Deprecated legacy parser used to convert externally provided input
+	 * literals. Use `replaceVariables()` and `coerceInputLiteral()` instead.
+	 * @deprecated use `replaceVariables()` and `coerceInputLiteral()` instead, `parseLiteral()` will be removed in v18
+	 */
+	parseLiteral?: GraphQLScalarLiteralParser<TInternal> | undefined;
+	/** Coerces an internal value to include in a response. */
+	coerceOutputValue?: GraphQLScalarOutputValueCoercer<TExternal> | undefined;
+	/** Coerces an externally provided value to use as an input. */
+	coerceInputValue?: GraphQLScalarInputValueCoercer<TInternal> | undefined;
+	/** Coerces an externally provided const literal value to use as an input. */
+	coerceInputLiteral?: GraphQLScalarInputLiteralCoercer<TInternal> | undefined;
+	/** Translates an externally provided value to a literal (AST). */
+	valueToLiteral?: GraphQLScalarValueToLiteral | undefined;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLScalarTypeExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<ScalarTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<ScalarTypeExtensionNode>>;
+}
+interface GraphQLScalarTypeNormalizedConfig<TInternal, TExternal> extends GraphQLScalarTypeConfig<TInternal, TExternal> {
+	serialize: GraphQLScalarSerializer<TExternal>;
+	parseValue: GraphQLScalarValueParser<TInternal>;
+	parseLiteral: GraphQLScalarLiteralParser<TInternal>;
+	coerceOutputValue: GraphQLScalarOutputValueCoercer<TExternal>;
+	coerceInputValue: GraphQLScalarInputValueCoercer<TInternal>;
+	coerceInputLiteral: GraphQLScalarInputLiteralCoercer<TInternal> | undefined;
+	extensions: Readonly<GraphQLScalarTypeExtensions>;
+	extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ * We've provided these template arguments because this is an open type and
+ * you may find them useful.
+ * @typeParam _TSource - Reserved source type parameter for extension typing.
+ * @typeParam _TContext - Reserved context type parameter for extension typing.
+ */
+export interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Object 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.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @typeParam TAbstract - Runtime value type used for abstract type resolution.
+ * @example
+ * ```ts
+ * const AddressType = new GraphQLObjectType({
+ *   name: 'Address',
+ *   fields: {
+ *     street: { type: GraphQLString },
+ *     number: { type: GraphQLInt },
+ *     formatted: {
+ *       type: GraphQLString,
+ *       resolve: (obj) => {
+ *         return obj.number + ' ' + obj.street;
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ * @example
+ * When two types need to refer to each other, or a type needs to refer to
+ * itself in a field, you can use a function expression (aka a closure or a
+ * thunk) to supply the fields lazily.
+ *
+ * ```ts
+ * const PersonType = new GraphQLObjectType({
+ *   name: 'Person',
+ *   fields: () => ({
+ *     name: { type: GraphQLString },
+ *     bestFriend: { type: PersonType },
+ *   }),
+ * });
+ * ```
+ */
+export declare class GraphQLObjectType<TSource = any, TContext = any, TAbstract = any> implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Predicate used to determine whether a runtime value belongs to this object type. */
+	isTypeOf: Maybe<GraphQLIsTypeOfFn<TAbstract, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<ObjectTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
+	private _fields;
+	private _interfaces;
+	/**
+	 * Creates a GraphQLObjectType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * // Configure an object type with interfaces, fields, arguments, and metadata.
+	 * import { parse } from 'graphql/language';
+	 * import {
+	 *   GraphQLID,
+	 *   GraphQLInterfaceType,
+	 *   GraphQLNonNull,
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   type User implements Node {
+	 *     id: ID!
+	 *     name(format: String = "short"): String
+	 *   }
+	 *
+	 *   extend type User {
+	 *     displayName: String
+	 *   }
+	 * `);
+	 * const definition = document.definitions[0];
+	 * const nameField = definition.fields[1];
+	 * const formatArg = nameField.arguments[0];
+	 *
+	 * const Node = new GraphQLInterfaceType({
+	 *   name: 'Node',
+	 *   fields: {
+	 *     id: { type: new GraphQLNonNull(GraphQLID) },
+	 *   },
+	 * });
+	 *
+	 * const User = new GraphQLObjectType({
+	 *   name: 'User',
+	 *   description: 'A registered user.',
+	 *   interfaces: [Node],
+	 *   fields: {
+	 *     id: { type: new GraphQLNonNull(GraphQLID) },
+	 *     name: {
+	 *       description: 'The formatted user name.',
+	 *       type: GraphQLString,
+	 *       args: {
+	 *         format: {
+	 *           description: 'Controls the name format.',
+	 *           type: GraphQLString,
+	 *           default: { value: 'short' },
+	 *           deprecationReason: 'Use locale instead.',
+	 *           extensions: { public: true },
+	 *           astNode: formatArg,
+	 *         },
+	 *       },
+	 *       resolve: (user, { format }) => {
+	 *         return format === 'long' ? user.fullName : user.name;
+	 *       },
+	 *       deprecationReason: 'Use displayName.',
+	 *       extensions: { cacheSeconds: 60 },
+	 *       astNode: nameField,
+	 *     },
+	 *   },
+	 *   isTypeOf: (value) => {
+	 *     return typeof value === 'object' && value != null && 'id' in value;
+	 *   },
+	 *   extensions: { entity: 'User' },
+	 *   astNode: definition,
+	 *   extensionASTNodes: [document.definitions[1]],
+	 * });
+	 *
+	 * User.name; // => 'User'
+	 * User.getInterfaces(); // => [Node]
+	 * Object.keys(User.getFields()); // => ['id', 'name']
+	 * User.getFields().name.args[0].default.value; // => 'short'
+	 * User.extensions; // => { entity: 'User' }
+	 * ```
+	 * @example
+	 * ```ts
+	 * // This variant configures a subscription field with subscribe and resolve functions.
+	 * import { GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Subscription = new GraphQLObjectType({
+	 *   name: 'Subscription',
+	 *   fields: {
+	 *     greeting: {
+	 *       type: GraphQLString,
+	 *       subscribe: async function* () {
+	 *         yield { greeting: 'Hello!' };
+	 *       },
+	 *       resolve: (event) => {
+	 *         return event.greeting;
+	 *       },
+	 *     },
+	 *   },
+	 * });
+	 *
+	 * typeof Subscription.getFields().greeting.subscribe; // => 'function'
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLObjectTypeConfig<TSource, TContext, TAbstract>>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the fields defined by this type.
+	 * @returns The fields keyed by field name.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   type User {
+	 *     id: ID!
+	 *     name: String
+	 *   }
+	 *
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 * `);
+	 *
+	 * const User = assertObjectType(schema.getType('User'));
+	 * const fields = User.getFields();
+	 *
+	 * Object.keys(fields); // => ['id', 'name']
+	 * String(fields.id.type); // => 'ID!'
+	 * ```
+	 */
+	getFields(): GraphQLFieldMap<TSource, TContext>;
+	/**
+	 * Returns the interfaces implemented by this type.
+	 * @returns The implemented interfaces.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type User implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 * `);
+	 *
+	 * const User = assertObjectType(schema.getType('User'));
+	 *
+	 * User.getInterfaces().map((type) => type.name); // => ['Node']
+	 * ```
+	 */
+	getInterfaces(): ReadonlyArray<GraphQLInterfaceType>;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const User = new GraphQLObjectType({
+	 *   name: 'User',
+	 *   fields: {
+	 *     name: { type: GraphQLString },
+	 *   },
+	 * });
+	 *
+	 * const config = User.toConfig();
+	 * const UserCopy = new GraphQLObjectType(config);
+	 *
+	 * config.fields.name.type; // => GraphQLString
+	 * UserCopy.getFields().name.type; // => GraphQLString
+	 * ```
+	 */
+	toConfig(): GraphQLObjectTypeNormalizedConfig<TSource, TContext, TAbstract>;
+	/**
+	 * Returns the schema coordinate identifying this object type.
+	 * @returns The schema coordinate for this object type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   type User {
+	 *     name: String
+	 *   }
+	 *
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 * `);
+	 *
+	 * const User = assertObjectType(schema.getType('User'));
+	 *
+	 * User.toString(); // => 'User'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const User = new GraphQLObjectType({
+	 *   name: 'User',
+	 *   fields: { name: { type: GraphQLString } },
+	 * });
+	 *
+	 * User.toJSON(); // => 'User'
+	 * JSON.stringify({ type: User }); // => '{"type":"User"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Configuration used to construct a GraphQLObjectType.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @typeParam TAbstract - Runtime value type used for abstract type resolution.
+ */
+export interface GraphQLObjectTypeConfig<TSource, TContext, TAbstract = unknown> {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Interfaces implemented by this object or interface type. */
+	interfaces?: ThunkReadonlyArray<GraphQLInterfaceType> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;
+	/** Predicate used to determine whether a runtime value belongs to this object type. */
+	isTypeOf?: Maybe<GraphQLIsTypeOfFn<TAbstract, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<ObjectTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<ObjectTypeExtensionNode>>;
+}
+interface GraphQLObjectTypeNormalizedConfig<TSource, TContext, TAbstract = unknown> extends GraphQLObjectTypeConfig<TSource, TContext, TAbstract> {
+	interfaces: ReadonlyArray<GraphQLInterfaceType>;
+	fields: GraphQLFieldNormalizedConfigMap<TSource, TContext>;
+	extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
+	extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
+}
+/**
+ * Resolves the concrete object type for an abstract GraphQL type.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export type GraphQLTypeResolver<TSource, TContext> = (value: TSource, context: TContext, info: GraphQLResolveInfo, abstractType: GraphQLAbstractType) => PromiseOrValue<string | undefined>;
+/**
+ * Checks whether a runtime value belongs to a GraphQL object type.
+ * @typeParam TAbstract - Runtime value type used for abstract type resolution.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export type GraphQLIsTypeOfFn<TAbstract, TContext> = (value: TAbstract, context: TContext, info: GraphQLResolveInfo) => PromiseOrValue<boolean>;
+/**
+ * Resolves the runtime value for a GraphQL field.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @typeParam TArgs - Argument object type passed to resolvers.
+ * @typeParam TResult - Result value type.
+ */
+export type GraphQLFieldResolver<TSource, TContext, TArgs = any, TResult = unknown> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult;
+/** Utilities available from resolver info for tracking asynchronous work. */
+export interface GraphQLResolveInfoHelpers {
+	/**
+	 * Promise.all wrapper that allows rejected branches to be tracked
+	 * as execution async work.
+	 *
+	 * Intended use: return or await this promise from resolver work.
+	 * Un-awaited async side effects are an anti-pattern:
+	 *
+	 *   const { promiseAll } = info.getAsyncHelpers();
+	 *   promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
+	 *
+	 * In that anti-pattern, tracking starts only after rejection (on a
+	 * later microtask), so this work is not guaranteed to delay
+	 * `hooks.asyncWorkFinished`.
+	 *
+	 * Use `track(...)` for un-awaited async side effects:
+	 *
+	 *   const { track } = info.getAsyncHelpers();
+	 *   track([
+	 *     someAsyncWork().catch(() => undefined),
+	 *     someOtherAsyncWork().catch(() => undefined)
+	 *   ]);
+	 */
+	readonly promiseAll: <T>(values: ReadonlyArray<PromiseLike<T> | T>) => Promise<Array<T>>;
+	/** Tracks asynchronous work that should delay execution completion hooks. */
+	readonly track: (maybePromises: ReadonlyArray<unknown>) => void;
+}
+/** Information about the currently executing GraphQL field. */
+export interface GraphQLResolveInfo {
+	/** The field name referenced by this schema coordinate. */
+	readonly fieldName: string;
+	/** AST field nodes that contributed to the current field execution. */
+	readonly fieldNodes: ReadonlyArray<FieldNode>;
+	/** GraphQL output type declared for the current field. */
+	readonly returnType: GraphQLOutputType;
+	/** Object type that owns the current field. */
+	readonly parentType: GraphQLObjectType;
+	/** Response path where this error occurred during execution. */
+	readonly path: Path;
+	/** The schema used for validation or execution. */
+	readonly schema: GraphQLSchema;
+	/** Fragment definitions in the operation document keyed by fragment name. */
+	readonly fragments: ObjMap<FragmentDefinitionNode>;
+	/** Initial root value passed to the operation. */
+	readonly rootValue: unknown;
+	/** The operation selected for execution. */
+	readonly operation: OperationDefinitionNode;
+	/**
+	 * Coerced variable values and source metadata for this operation. Resolver
+	 * code that needs runtime variable values should read `variableValues.coerced`.
+	 */
+	readonly variableValues: VariableValues;
+	/** Returns the AbortSignal supplied for this execution, if any. */
+	readonly getAbortSignal: () => AbortSignal | undefined;
+	/** Returns helper functions for tracking asynchronous resolver work. */
+	readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ * We've provided these template arguments because this is an open type and
+ * you may find them useful.
+ * @typeParam _TSource - Reserved source type parameter for extension typing.
+ * @typeParam _TContext - Reserved context type parameter for extension typing.
+ * @typeParam _TArgs - Reserved argument type parameter for extension typing.
+ */
+export interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Configuration used to define a GraphQL field.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @typeParam TArgs - Argument object type passed to resolvers.
+ */
+export interface GraphQLFieldConfig<TSource, TContext, TArgs = any> {
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLOutputType;
+	/** Arguments accepted by this field or directive. */
+	args?: GraphQLFieldConfigArgumentMap | undefined;
+	/** Resolver function used to produce this field value. */
+	resolve?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;
+	/** Resolver function used to create a subscription event stream for this field. */
+	subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason?: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<FieldDefinitionNode>;
+}
+interface GraphQLFieldNormalizedConfig<TSource, TContext, TArgs = any> extends GraphQLFieldConfig<TSource, TContext, TArgs> {
+	args: GraphQLFieldNormalizedConfigArgumentMap;
+	extensions: Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>;
+}
+/** A map of argument names to argument configuration objects. */
+export type GraphQLFieldConfigArgumentMap = ObjMap<GraphQLArgumentConfig>;
+type GraphQLFieldNormalizedConfigArgumentMap = ObjMap<GraphQLArgumentNormalizedConfig>;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLArgumentExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL argument. */
+export interface GraphQLArgumentConfig {
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLInputType;
+	/**
+	 * Deprecated legacy default value for this argument. Use `default` instead.
+	 * @deprecated use `default` instead, `defaultValue` will be removed in v18
+	 */
+	defaultValue?: unknown;
+	/** Default value represented as either a runtime value or a GraphQL literal. */
+	default?: GraphQLDefaultInput | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason?: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLArgumentExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<InputValueDefinitionNode>;
+}
+interface GraphQLArgumentNormalizedConfig extends GraphQLArgumentConfig {
+	default: GraphQLDefaultInput | undefined;
+	extensions: Readonly<GraphQLArgumentExtensions>;
+}
+/**
+ * A map of field names to field configuration objects.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export type GraphQLFieldConfigMap<TSource, TContext> = ObjMap<GraphQLFieldConfig<TSource, TContext>>;
+type GraphQLFieldNormalizedConfigMap<TSource, TContext> = ObjMap<GraphQLFieldNormalizedConfig<TSource, TContext>>;
+/**
+ * A resolved GraphQL field definition.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @typeParam TArgs - Argument object type passed to resolvers.
+ */
+export declare class GraphQLField<TSource = any, TContext = any, TArgs = any> implements GraphQLSchemaElement {
+	/** Object or interface type that owns this field, if known. */
+	parentType: GraphQLObjectType<TSource, TContext> | GraphQLInterfaceType<TSource, TContext> | undefined;
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLOutputType;
+	/** Arguments accepted by this field or directive. */
+	args: ReadonlyArray<GraphQLArgument>;
+	/** Resolver function used to produce this field value. */
+	resolve?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;
+	/** Resolver function used to create a subscription event stream for this field. */
+	subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<FieldDefinitionNode>;
+	/**
+	 * Creates a resolved GraphQL field definition.
+	 * @param parentType - Object or interface type that owns this field, if known.
+	 * @param name - Field name.
+	 * @param config - Field configuration.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const document = parse('type Query { greeting: String }');
+	 * const fieldNode = document.definitions[0].fields[0];
+	 * const field = new GraphQLField(Query, 'greeting', {
+	 *   description: 'Greeting text.',
+	 *   type: GraphQLString,
+	 *   args: {
+	 *     name: { type: GraphQLString, default: { value: 'world' } },
+	 *   },
+	 *   resolve: (_source, { name }) => `Hello, ${name}!`,
+	 *   subscribe: async function* () {
+	 *     yield { greeting: 'Hello!' };
+	 *   },
+	 *   deprecationReason: 'Use hello.',
+	 *   extensions: { cacheSeconds: 60 },
+	 *   astNode: fieldNode,
+	 * });
+	 *
+	 * field.parentType; // => Query
+	 * field.name; // => 'greeting'
+	 * field.args[0].default.value; // => 'world'
+	 * typeof field.subscribe; // => 'function'
+	 * field.deprecationReason; // => 'Use hello.'
+	 * field.astNode; // => fieldNode
+	 * ```
+	 */
+	constructor(parentType: GraphQLObjectType<TSource, TContext> | GraphQLInterfaceType<TSource, TContext> | undefined, name: string, config: GraphQLFieldConfig<TSource, TContext, TArgs>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this field.
+	 * @returns A configuration object that can be used to recreate this field.
+	 * @example
+	 * ```ts
+	 * import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', {
+	 *   type: GraphQLString,
+	 *   extensions: { cacheSeconds: 60 },
+	 * });
+	 *
+	 * field.toConfig().type; // => GraphQLString
+	 * field.toConfig().extensions; // => { cacheSeconds: 60 }
+	 * ```
+	 */
+	toConfig(): GraphQLFieldNormalizedConfig<TSource, TContext, TArgs>;
+	/**
+	 * Returns this field as a schema coordinate string.
+	 * @returns The field coordinate.
+	 * @example
+	 * ```ts
+	 * import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 *
+	 * field.toString(); // => 'Query.greeting'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The field coordinate.
+	 * @example
+	 * ```ts
+	 * import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 *
+	 * JSON.stringify(field); // => '"Query.greeting"'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/** A resolved GraphQL argument definition. */
+export declare class GraphQLArgument implements GraphQLSchemaElement {
+	/** Field or directive that owns this argument. */
+	parent: GraphQLField | GraphQLDirective;
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLInputType;
+	/**
+	 * Deprecated legacy default value used when no explicit value is supplied.
+	 * Use `default` instead.
+	 * @deprecated use `default` instead, `defaultValue` will be removed in v18
+	 */
+	defaultValue: unknown;
+	/** Default value represented as either a runtime value or a GraphQL literal. */
+	default: GraphQLDefaultInput | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLArgumentExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<InputValueDefinitionNode>;
+	/**
+	 * Creates a resolved GraphQL argument definition.
+	 * @param parent - Field or directive that owns this argument.
+	 * @param name - Argument name.
+	 * @param config - Argument configuration.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLArgument,
+	 *   GraphQLField,
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 * const arg = new GraphQLArgument(field, 'name', {
+	 *   type: GraphQLString,
+	 *   default: { value: 'world' },
+	 * });
+	 *
+	 * arg.parent; // => field
+	 * arg.name; // => 'name'
+	 * arg.default.value; // => 'world'
+	 * ```
+	 */
+	constructor(parent: GraphQLField | GraphQLDirective, name: string, config: GraphQLArgumentConfig);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this argument.
+	 * @returns A configuration object that can be used to recreate this argument.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLArgument,
+	 *   GraphQLField,
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 * const arg = new GraphQLArgument(field, 'name', {
+	 *   type: GraphQLString,
+	 *   default: { value: 'world' },
+	 * });
+	 *
+	 * arg.toConfig().default.value; // => 'world'
+	 * ```
+	 */
+	toConfig(): GraphQLArgumentNormalizedConfig;
+	/**
+	 * Returns this argument as a schema coordinate string.
+	 * @returns The argument coordinate.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLArgument,
+	 *   GraphQLField,
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 * const arg = new GraphQLArgument(field, 'name', { type: GraphQLString });
+	 *
+	 * arg.toString(); // => 'Query.greeting(name:)'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The argument coordinate.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLArgument,
+	 *   GraphQLField,
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+	 * const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
+	 * const arg = new GraphQLArgument(field, 'name', { type: GraphQLString });
+	 *
+	 * JSON.stringify(arg); // => '"Query.greeting(name:)"'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Returns true when the argument is non-null and has no default value.
+ * @param arg - The argument definition to inspect.
+ * @returns True when the argument is non-null and has no default value.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLArgument,
+ *   GraphQLField,
+ *   GraphQLInt,
+ *   GraphQLNonNull,
+ *   GraphQLObjectType,
+ *   GraphQLString,
+ *   isRequiredArgument,
+ * } from 'graphql/type';
+ *
+ * const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
+ * const field = new GraphQLField(Query, 'reviews', { type: GraphQLString });
+ * const requiredArgument = new GraphQLArgument(field, 'id', {
+ *   type: new GraphQLNonNull(GraphQLInt),
+ * });
+ * const optionalArgument = new GraphQLArgument(field, 'name', {
+ *   type: GraphQLString,
+ * });
+ * const argumentWithDefault = new GraphQLArgument(field, 'limit', {
+ *   type: new GraphQLNonNull(GraphQLInt),
+ *   default: { value: 10 },
+ * });
+ *
+ * isRequiredArgument(requiredArgument); // => true
+ * isRequiredArgument(optionalArgument); // => false
+ * isRequiredArgument(argumentWithDefault); // => false
+ * ```
+ */
+export declare function isRequiredArgument(arg: GraphQLArgument | GraphQLVariableSignature): boolean;
+/**
+ * A map of field names to resolved field definitions.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export type GraphQLFieldMap<TSource, TContext> = ObjMap<GraphQLField<TSource, TContext>>;
+/** Default input represented as either a runtime value or a GraphQL literal. */
+export type GraphQLDefaultInput = {
+	/** Runtime default value. */
+	value: unknown;
+	/** GraphQL literal default value is not provided in this variant. */
+	literal?: never;
+} | {
+	/** GraphQL literal default value. */
+	literal: ConstValueNode;
+	/** Runtime default value is not provided in this variant. */
+	value?: never;
+};
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLInterfaceTypeExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Interface 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, what fields are in common across
+ * all types, as well as a function to determine which type is actually used
+ * when the field is resolved.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @example
+ * ```ts
+ * const EntityType = new GraphQLInterfaceType({
+ *   name: 'Entity',
+ *   fields: {
+ *     name: { type: GraphQLString },
+ *   },
+ * });
+ * ```
+ */
+export declare class GraphQLInterfaceType<TSource = any, TContext = any> implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Function that resolves the concrete object type for this abstract type. */
+	resolveType: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLInterfaceTypeExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<InterfaceTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<InterfaceTypeExtensionNode>;
+	private _fields;
+	private _interfaces;
+	/**
+	 * Creates a GraphQLInterfaceType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { GraphQLID, GraphQLInterfaceType, GraphQLNonNull } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   interface Resource implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   extend interface Resource {
+	 *     url: String
+	 *   }
+	 * `);
+	 *
+	 * const Node = new GraphQLInterfaceType({
+	 *   name: 'Node',
+	 *   fields: {
+	 *     id: { type: new GraphQLNonNull(GraphQLID) },
+	 *   },
+	 * });
+	 *
+	 * const Resource = new GraphQLInterfaceType({
+	 *   name: 'Resource',
+	 *   description: 'An addressable resource.',
+	 *   interfaces: [Node],
+	 *   fields: {
+	 *     id: { type: new GraphQLNonNull(GraphQLID) },
+	 *   },
+	 *   resolveType: (value) => {
+	 *     return typeof value === 'object' && value != null && 'url' in value
+	 *       ? 'WebPage'
+	 *       : null;
+	 *   },
+	 *   extensions: { abstract: true },
+	 *   astNode: document.definitions[1],
+	 *   extensionASTNodes: [document.definitions[2]],
+	 * });
+	 *
+	 * Resource.name; // => 'Resource'
+	 * Resource.getInterfaces(); // => [Node]
+	 * Object.keys(Resource.getFields()); // => ['id']
+	 * Resource.extensions; // => { abstract: true }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLInterfaceTypeConfig<TSource, TContext>>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the fields defined by this type.
+	 * @returns The fields keyed by field name.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type User implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type Query {
+	 *     node: Node
+	 *   }
+	 * `);
+	 *
+	 * const Node = assertInterfaceType(schema.getType('Node'));
+	 * const fields = Node.getFields();
+	 *
+	 * Object.keys(fields); // => ['id']
+	 * String(fields.id.type); // => 'ID!'
+	 * ```
+	 */
+	getFields(): GraphQLFieldMap<TSource, TContext>;
+	/**
+	 * Returns the interfaces implemented by this type.
+	 * @returns The implemented interfaces.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Resource {
+	 *     url: String!
+	 *   }
+	 *
+	 *   interface Image implements Resource {
+	 *     url: String!
+	 *     width: Int
+	 *   }
+	 *
+	 *   type Photo implements Resource & Image {
+	 *     url: String!
+	 *     width: Int
+	 *   }
+	 *
+	 *   type Query {
+	 *     image: Image
+	 *   }
+	 * `);
+	 *
+	 * const Image = assertInterfaceType(schema.getType('Image'));
+	 *
+	 * Image.getInterfaces().map((type) => type.name); // => ['Resource']
+	 * ```
+	 */
+	getInterfaces(): ReadonlyArray<GraphQLInterfaceType>;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { GraphQLID, GraphQLInterfaceType, GraphQLNonNull } from 'graphql/type';
+	 *
+	 * const Node = new GraphQLInterfaceType({
+	 *   name: 'Node',
+	 *   fields: {
+	 *     id: { type: new GraphQLNonNull(GraphQLID) },
+	 *   },
+	 * });
+	 *
+	 * const config = Node.toConfig();
+	 * const NodeCopy = new GraphQLInterfaceType(config);
+	 *
+	 * String(config.fields.id.type); // => 'ID!'
+	 * String(NodeCopy.getFields().id.type); // => 'ID!'
+	 * ```
+	 */
+	toConfig(): GraphQLInterfaceTypeNormalizedConfig<TSource, TContext>;
+	/**
+	 * Returns the schema coordinate identifying this interface type.
+	 * @returns The schema coordinate for this interface type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type User implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type Query {
+	 *     node: Node
+	 *   }
+	 * `);
+	 *
+	 * const Node = assertInterfaceType(schema.getType('Node'));
+	 *
+	 * Node.toString(); // => 'Node'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLInterfaceType, GraphQLString } from 'graphql/type';
+	 *
+	 * const Named = new GraphQLInterfaceType({
+	 *   name: 'Named',
+	 *   fields: { name: { type: GraphQLString } },
+	 * });
+	 *
+	 * Named.toJSON(); // => 'Named'
+	 * JSON.stringify({ type: Named }); // => '{"type":"Named"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Configuration used to construct a GraphQLInterfaceType.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export interface GraphQLInterfaceTypeConfig<TSource, TContext> {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Interfaces implemented by this object or interface type. */
+	interfaces?: ThunkReadonlyArray<GraphQLInterfaceType> | undefined;
+	/** Fields declared by this object, interface, input object, or literal. */
+	fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;
+	/**
+	 * Optionally provide a custom type resolver function. If one is not provided,
+	 * the default implementation will call `isTypeOf` on each implementing
+	 * Object type.
+	 */
+	resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLInterfaceTypeExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<InterfaceTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<InterfaceTypeExtensionNode>>;
+}
+interface GraphQLInterfaceTypeNormalizedConfig<TSource, TContext> extends GraphQLInterfaceTypeConfig<TSource, TContext> {
+	interfaces: ReadonlyArray<GraphQLInterfaceType>;
+	fields: GraphQLFieldNormalizedConfigMap<TSource, TContext>;
+	extensions: Readonly<GraphQLInterfaceTypeExtensions>;
+	extensionASTNodes: ReadonlyArray<InterfaceTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLUnionTypeExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Union 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 as well as providing a function
+ * to determine which type is actually used when the field is resolved.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ * @example
+ * ```ts
+ * const PetType = new GraphQLUnionType({
+ *   name: 'Pet',
+ *   types: [DogType, CatType],
+ *   resolveType: (value) => {
+ *     if (value instanceof Dog) {
+ *       return DogType;
+ *     }
+ *     if (value instanceof Cat) {
+ *       return CatType;
+ *     }
+ *   },
+ * });
+ * ```
+ */
+export declare class GraphQLUnionType<TSource = any, TContext = any> implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Function that resolves the concrete object type for this abstract type. */
+	resolveType: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLUnionTypeExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<UnionTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
+	private _types;
+	/**
+	 * Creates a GraphQLUnionType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import {
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 *   GraphQLUnionType,
+	 * } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   union Media = Photo | Video
+	 *
+	 *   extend union Media = Audio
+	 * `);
+	 *
+	 * const Photo = new GraphQLObjectType({
+	 *   name: 'Photo',
+	 *   fields: { url: { type: GraphQLString } },
+	 * });
+	 * const Video = new GraphQLObjectType({
+	 *   name: 'Video',
+	 *   fields: { url: { type: GraphQLString } },
+	 * });
+	 *
+	 * const Media = new GraphQLUnionType({
+	 *   name: 'Media',
+	 *   description: 'Media that can appear in a search result.',
+	 *   types: [Photo, Video],
+	 *   resolveType: (value) => {
+	 *     return typeof value === 'object' && value != null && 'duration' in value
+	 *       ? 'Video'
+	 *       : 'Photo';
+	 *   },
+	 *   extensions: { searchable: true },
+	 *   astNode: document.definitions[0],
+	 *   extensionASTNodes: [document.definitions[1]],
+	 * });
+	 *
+	 * Media.description; // => 'Media that can appear in a search result.'
+	 * Media.getTypes().map((type) => type.name); // => ['Photo', 'Video']
+	 * Media.extensions; // => { searchable: true }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLUnionTypeConfig<TSource, TContext>>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the object types included in this union.
+	 * @returns The union member object types.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertUnionType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Photo {
+	 *     url: String!
+	 *   }
+	 *
+	 *   type Video {
+	 *     url: String!
+	 *   }
+	 *
+	 *   union Media = Photo | Video
+	 *
+	 *   type Query {
+	 *     media: [Media]
+	 *   }
+	 * `);
+	 *
+	 * const Media = assertUnionType(schema.getType('Media'));
+	 *
+	 * Media.getTypes().map((type) => type.name); // => ['Photo', 'Video']
+	 * ```
+	 */
+	getTypes(): ReadonlyArray<GraphQLObjectType>;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 *   GraphQLUnionType,
+	 * } from 'graphql/type';
+	 *
+	 * const Photo = new GraphQLObjectType({
+	 *   name: 'Photo',
+	 *   fields: { url: { type: GraphQLString } },
+	 * });
+	 * const Video = new GraphQLObjectType({
+	 *   name: 'Video',
+	 *   fields: { url: { type: GraphQLString } },
+	 * });
+	 * const Media = new GraphQLUnionType({
+	 *   name: 'Media',
+	 *   types: [Photo, Video],
+	 * });
+	 *
+	 * const config = Media.toConfig();
+	 * const MediaCopy = new GraphQLUnionType(config);
+	 *
+	 * MediaCopy.getTypes().map((type) => type.name); // => ['Photo', 'Video']
+	 * ```
+	 */
+	toConfig(): GraphQLUnionTypeNormalizedConfig<TSource, TContext>;
+	/**
+	 * Returns the schema coordinate identifying this union type.
+	 * @returns The schema coordinate for this union type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertUnionType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Photo {
+	 *     url: String!
+	 *   }
+	 *
+	 *   union SearchResult = Photo
+	 *
+	 *   type Query {
+	 *     search: [SearchResult]
+	 *   }
+	 * `);
+	 *
+	 * const SearchResult = assertUnionType(schema.getType('SearchResult'));
+	 *
+	 * SearchResult.toString(); // => 'SearchResult'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLObjectType,
+	 *   GraphQLString,
+	 *   GraphQLUnionType,
+	 * } from 'graphql/type';
+	 *
+	 * const Photo = new GraphQLObjectType({
+	 *   name: 'Photo',
+	 *   fields: { url: { type: GraphQLString } },
+	 * });
+	 * const SearchResult = new GraphQLUnionType({
+	 *   name: 'SearchResult',
+	 *   types: [Photo],
+	 * });
+	 *
+	 * SearchResult.toJSON(); // => 'SearchResult'
+	 * JSON.stringify({ type: SearchResult }); // => '{"type":"SearchResult"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Configuration used to construct a GraphQLUnionType.
+ * @typeParam TSource - Source object type passed to resolvers.
+ * @typeParam TContext - Context object type passed to resolvers.
+ */
+export interface GraphQLUnionTypeConfig<TSource, TContext> {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Object types that belong to this union type. */
+	types: ThunkReadonlyArray<GraphQLObjectType>;
+	/**
+	 * Optionally provide a custom type resolver function. If one is not provided,
+	 * the default implementation will call `isTypeOf` on each implementing
+	 * Object type.
+	 */
+	resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLUnionTypeExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<UnionTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<UnionTypeExtensionNode>>;
+}
+interface GraphQLUnionTypeNormalizedConfig<TSource, TContext> extends GraphQLUnionTypeConfig<TSource, TContext> {
+	types: ReadonlyArray<GraphQLObjectType>;
+	extensions: Readonly<GraphQLUnionTypeExtensions>;
+	extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLEnumTypeExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Enum Type Definition
+ *
+ * Enum types define leaf values whose serialized form is one of a fixed set
+ * of GraphQL enum names. Internally, enum values can map to any runtime value,
+ * often integers.
+ * @example
+ * ```ts
+ * import { GraphQLEnumType } from 'graphql/type';
+ *
+ * const RGBType = new GraphQLEnumType({
+ *   name: 'RGB',
+ *   values: {
+ *     RED: { value: 0 },
+ *     GREEN: { value: 1 },
+ *     BLUE: { value: 2 },
+ *   },
+ * });
+ *
+ * RGBType.getValue('GREEN')?.value; // => 1
+ * ```
+ *
+ * Note: If a value is not provided in a definition, the name of the enum value
+ * will be used as its internal value.
+ */
+export declare class GraphQLEnumType /* <T> *//* <T> */  implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLEnumTypeExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<EnumTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
+	private _values;
+	private _valueLookup;
+	private _nameLookup;
+	/**
+	 * Creates a GraphQLEnumType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   enum Episode {
+	 *     NEW_HOPE
+	 *     EMPIRE
+	 *     JEDI
+	 *   }
+	 *
+	 *   extend enum Episode {
+	 *     FORCE_AWAKENS
+	 *   }
+	 * `);
+	 * const definition = document.definitions[0];
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   description: 'A Star Wars film episode.',
+	 *   values: {
+	 *     NEW_HOPE: {
+	 *       value: 4,
+	 *       description: 'Released in 1977.',
+	 *       extensions: { trilogy: 'original' },
+	 *       astNode: definition.values[0],
+	 *     },
+	 *     EMPIRE: { value: 5, astNode: definition.values[1] },
+	 *     JEDI: {
+	 *       value: 6,
+	 *       deprecationReason: 'Use RETURN_OF_THE_JEDI.',
+	 *       astNode: definition.values[2],
+	 *     },
+	 *   },
+	 *   extensions: { catalog: 'films' },
+	 *   astNode: definition,
+	 *   extensionASTNodes: [document.definitions[1]],
+	 * });
+	 *
+	 * Episode.description; // => 'A Star Wars film episode.'
+	 * Episode.coerceOutputValue(5); // => 'EMPIRE'
+	 * Episode.coerceInputValue('JEDI'); // => 6
+	 * Episode.getValue('JEDI').deprecationReason; // => 'Use RETURN_OF_THE_JEDI.'
+	 * Episode.extensions; // => { catalog: 'films' }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLEnumTypeConfig>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the values defined by this enum type.
+	 * @returns Enum value definitions in schema order.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertEnumType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   enum Episode {
+	 *     NEW_HOPE
+	 *     EMPIRE
+	 *     JEDI
+	 *   }
+	 *
+	 *   type Query {
+	 *     episode: Episode
+	 *   }
+	 * `);
+	 *
+	 * const Episode = assertEnumType(schema.getType('Episode'));
+	 *
+	 * Episode.getValues().map((value) => value.name); // => ['NEW_HOPE', 'EMPIRE', 'JEDI']
+	 * ```
+	 */
+	getValues(): ReadonlyArray<GraphQLEnumValue>;
+	/**
+	 * Returns the enum value definition for a value name.
+	 * @param name - The GraphQL name to look up.
+	 * @returns The matching enum value definition, if it exists.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertEnumType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   enum Episode {
+	 *     NEW_HOPE
+	 *     EMPIRE
+	 *   }
+	 *
+	 *   type Query {
+	 *     episode: Episode
+	 *   }
+	 * `);
+	 *
+	 * const Episode = assertEnumType(schema.getType('Episode'));
+	 *
+	 * Episode.getValue('EMPIRE')?.name; // => 'EMPIRE'
+	 * Episode.getValue('JEDI'); // => undefined
+	 * ```
+	 */
+	getValue(name: string): Maybe<GraphQLEnumValue>;
+	/**
+	 * Serializes a runtime enum value as a GraphQL enum name.
+	 * @param outputValue - Runtime enum value to serialize.
+	 * @returns The GraphQL enum name for the runtime value.
+	 *
+	 * This deprecated method delegates to `coerceOutputValue()`; call
+	 * `coerceOutputValue()` directly instead.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.serialize(1); // => 'GREEN'
+	 * RGB.serialize(3); // throws an error
+	 * ```
+	 * @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18
+	 */
+	serialize(outputValue: unknown): Maybe<string>;
+	/**
+	 * Coerces a runtime enum value to a GraphQL enum name.
+	 * @param outputValue - Runtime enum value to coerce.
+	 * @returns The GraphQL enum name for the runtime value.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.coerceOutputValue(1); // => 'GREEN'
+	 * RGB.coerceOutputValue(3); // throws an error
+	 * ```
+	 */
+	coerceOutputValue(outputValue: unknown): Maybe<string>;
+	/**
+	 * Deprecated legacy enum parser for externally provided input values. Use
+	 * `coerceInputValue()` instead.
+	 * @param inputValue - External enum name to parse.
+	 * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+	 * @returns The internal runtime value for the enum name.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.parseValue('BLUE'); // => 2
+	 * RGB.parseValue('PURPLE', true); // throws an error
+	 * ```
+	 * @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18
+	 */
+	parseValue(inputValue: unknown, hideSuggestions?: Maybe<boolean>): Maybe<any>;
+	/**
+	 * Coerces an external enum name to its internal runtime value.
+	 * @param inputValue - External enum name to coerce.
+	 * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+	 * @returns The internal runtime value for the enum name.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.coerceInputValue('BLUE'); // => 2
+	 * RGB.coerceInputValue('PURPLE'); // throws an error
+	 * RGB.coerceInputValue(2); // throws an error
+	 * ```
+	 */
+	coerceInputValue(inputValue: unknown, hideSuggestions?: Maybe<boolean>): Maybe<any>;
+	/**
+	 * Deprecated legacy enum parser for externally provided input literals. Use
+	 * `coerceInputLiteral()` instead.
+	 * @param valueNode - Enum value AST node to parse.
+	 * @param _variables - Deprecated variable values parameter that is no longer used.
+	 * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+	 * @returns The internal runtime value for the enum literal.
+	 * @example
+	 * ```ts
+	 * import { parseValue } from 'graphql/language';
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.parseLiteral(parseValue('RED')); // => 0
+	 * RGB.parseLiteral(parseValue('"RED"')); // throws an error
+	 * ```
+	 * @deprecated use `coerceInputLiteral()` instead, `parseLiteral()` will be removed in v18
+	 */
+	parseLiteral(valueNode: ValueNode, _variables: Maybe<ObjMap<unknown>>, hideSuggestions?: Maybe<boolean>): Maybe<any>;
+	/**
+	 * Coerces an enum value AST node to its internal runtime value.
+	 * @param valueNode - Enum value AST node to coerce.
+	 * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+	 * @returns The internal runtime value for the enum literal.
+	 * @example
+	 * ```ts
+	 * import { parseConstValue } from 'graphql/language';
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * RGB.coerceInputLiteral(parseConstValue('RED')); // => 0
+	 * RGB.coerceInputLiteral(parseConstValue('"RED"'), true); // throws an error
+	 * ```
+	 */
+	coerceInputLiteral(valueNode: ConstValueNode, hideSuggestions?: Maybe<boolean>): Maybe<any>;
+	/**
+	 * Converts a runtime enum value to a GraphQL enum value AST node.
+	 * @param value - Runtime enum value to convert.
+	 * @returns Enum value AST node, or undefined if the value is invalid.
+	 * @example
+	 * ```ts
+	 * import { print } from 'graphql/language';
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * print(RGB.valueToLiteral(2)); // => 'BLUE'
+	 * RGB.valueToLiteral(3); // => undefined
+	 * ```
+	 */
+	valueToLiteral(value: unknown): ConstValueNode | undefined;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const RGB = new GraphQLEnumType({
+	 *   name: 'RGB',
+	 *   values: {
+	 *     RED: { value: 0 },
+	 *     GREEN: { value: 1 },
+	 *     BLUE: { value: 2 },
+	 *   },
+	 * });
+	 *
+	 * const config = RGB.toConfig();
+	 * const RGBCopy = new GraphQLEnumType(config);
+	 *
+	 * config.values.GREEN.value; // => 1
+	 * RGBCopy.coerceOutputValue(2); // => 'BLUE'
+	 * ```
+	 */
+	toConfig(): GraphQLEnumTypeNormalizedConfig;
+	/**
+	 * Returns the schema coordinate identifying this enum type.
+	 * @returns The schema coordinate for this enum type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertEnumType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   enum Episode {
+	 *     NEW_HOPE
+	 *   }
+	 *
+	 *   type Query {
+	 *     episode: Episode
+	 *   }
+	 * `);
+	 *
+	 * const Episode = assertEnumType(schema.getType('Episode'));
+	 *
+	 * Episode.toString(); // => 'Episode'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType } from 'graphql/type';
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   values: {
+	 *     NEW_HOPE: {},
+	 *   },
+	 * });
+	 *
+	 * Episode.toJSON(); // => 'Episode'
+	 * JSON.stringify({ type: Episode }); // => '{"type":"Episode"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/** Configuration used to construct a GraphQLEnumType. */
+export interface GraphQLEnumTypeConfig {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Values contained in this enum, list, or input-object definition. */
+	values: ThunkObjMap<GraphQLEnumValueConfig>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLEnumTypeExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<EnumTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<EnumTypeExtensionNode>>;
+}
+interface GraphQLEnumTypeNormalizedConfig extends GraphQLEnumTypeConfig {
+	values: GraphQLEnumValueNormalizedConfigMap;
+	extensions: Readonly<GraphQLEnumTypeExtensions>;
+	extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
+}
+/** A map of enum value names to enum value configuration objects. */
+export type GraphQLEnumValueConfigMap = ObjMap<GraphQLEnumValueConfig>;
+type GraphQLEnumValueNormalizedConfigMap = ObjMap<GraphQLEnumValueNormalizedConfig>;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLEnumValueExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL enum value. */
+export interface GraphQLEnumValueConfig {
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Parsed value represented by this node. */
+	value?: any;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason?: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLEnumValueExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<EnumValueDefinitionNode>;
+}
+interface GraphQLEnumValueNormalizedConfig extends GraphQLEnumValueConfig {
+	extensions: Readonly<GraphQLEnumValueExtensions>;
+}
+/** A resolved GraphQL enum value definition. */
+export declare class GraphQLEnumValue implements GraphQLSchemaElement {
+	/** Enum type that owns this enum value. */
+	parentEnum: GraphQLEnumType;
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Parsed value represented by this node. */
+	value: any;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLEnumValueExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<EnumValueDefinitionNode>;
+	/**
+	 * Creates a resolved GraphQL enum value definition.
+	 * @param parentEnum - Enum type that owns this enum value.
+	 * @param name - Enum value name.
+	 * @param config - Enum value configuration.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   values: { NEW_HOPE: { value: 4 } },
+	 * });
+	 * const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', {
+	 *   value: 5,
+	 *   description: 'Released in 1980.',
+	 * });
+	 *
+	 * enumValue.parentEnum; // => Episode
+	 * enumValue.name; // => 'EMPIRE'
+	 * enumValue.value; // => 5
+	 * ```
+	 */
+	constructor(parentEnum: GraphQLEnumType, name: string, config: GraphQLEnumValueConfig);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this enum value.
+	 * @returns A configuration object that can be used to recreate this enum value.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   values: { NEW_HOPE: { value: 4 } },
+	 * });
+	 * const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', {
+	 *   value: 5,
+	 *   extensions: { trilogy: 'original' },
+	 * });
+	 *
+	 * enumValue.toConfig(); // => { description: undefined, value: 5, deprecationReason: undefined, extensions: { trilogy: 'original' }, astNode: undefined }
+	 * ```
+	 */
+	toConfig(): GraphQLEnumValueNormalizedConfig;
+	/**
+	 * Returns this enum value as a schema coordinate string.
+	 * @returns Enum value coordinate.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   values: { NEW_HOPE: { value: 4 } },
+	 * });
+	 * const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', { value: 5 });
+	 *
+	 * enumValue.toString(); // => 'Episode.EMPIRE'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns Enum value coordinate.
+	 * @example
+	 * ```ts
+	 * import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';
+	 *
+	 * const Episode = new GraphQLEnumType({
+	 *   name: 'Episode',
+	 *   values: { NEW_HOPE: { value: 4 } },
+	 * });
+	 * const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', { value: 5 });
+	 *
+	 * JSON.stringify(enumValue); // => '"Episode.EMPIRE"'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLInputObjectTypeExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Input Object Type Definition
+ *
+ * An input object defines a structured collection of fields which may be
+ * supplied to a field argument.
+ *
+ * Using `NonNull` will ensure that a value must be provided by the query
+ * @example
+ * ```ts
+ * const GeoPoint = new GraphQLInputObjectType({
+ *   name: 'GeoPoint',
+ *   fields: {
+ *     lat: { type: new GraphQLNonNull(GraphQLFloat) },
+ *     lon: { type: new GraphQLNonNull(GraphQLFloat) },
+ *     alt: { type: GraphQLFloat, default: { value: 0 } },
+ *   },
+ * });
+ * ```
+ */
+export declare class GraphQLInputObjectType implements GraphQLSchemaElement {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLInputObjectTypeExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<InputObjectTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
+	/** Whether this input object uses the experimental OneOf input object semantics. */
+	isOneOf: boolean;
+	private _fields;
+	/**
+	 * Creates a GraphQLInputObjectType instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import {
+	 *   GraphQLID,
+	 *   GraphQLInputObjectType,
+	 *   GraphQLInt,
+	 *   GraphQLNonNull,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const document = parse(`
+	 *   input ReviewInput {
+	 *     stars: Int!
+	 *     commentary: String
+	 *   }
+	 *
+	 *   extend input ReviewInput {
+	 *     body: String
+	 *   }
+	 * `);
+	 * const definition = document.definitions[0];
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   description: 'Input collected when reviewing a product.',
+	 *   fields: {
+	 *     stars: {
+	 *       description: 'Star rating from one to five.',
+	 *       type: new GraphQLNonNull(GraphQLInt),
+	 *       extensions: { min: 1, max: 5 },
+	 *       astNode: definition.fields[0],
+	 *     },
+	 *     commentary: {
+	 *       type: GraphQLString,
+	 *       default: { value: '' },
+	 *       deprecationReason: 'Use body.',
+	 *       astNode: definition.fields[1],
+	 *     },
+	 *   },
+	 *   extensions: { form: 'review' },
+	 *   astNode: definition,
+	 *   extensionASTNodes: [document.definitions[1]],
+	 *   isOneOf: false,
+	 * });
+	 * const SearchBy = new GraphQLInputObjectType({
+	 *   name: 'SearchBy',
+	 *   fields: {
+	 *     id: { type: GraphQLID },
+	 *     slug: { type: GraphQLString },
+	 *   },
+	 *   isOneOf: true,
+	 * });
+	 *
+	 * const fields = ReviewInput.getFields();
+	 *
+	 * ReviewInput.description; // => 'Input collected when reviewing a product.'
+	 * String(fields.stars.type); // => 'Int!'
+	 * fields.stars.extensions; // => { min: 1, max: 5 }
+	 * fields.commentary.default.value; // => ''
+	 * fields.commentary.deprecationReason; // => 'Use body.'
+	 * ReviewInput.isOneOf; // => false
+	 * SearchBy.isOneOf; // => true
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLInputObjectTypeConfig>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the fields defined by this type.
+	 * @returns The fields keyed by field name.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInputObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   input ReviewInput {
+	 *     stars: Int!
+	 *     commentary: String = ""
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(filter: ReviewInput): [String]
+	 *   }
+	 * `);
+	 *
+	 * const ReviewInput = assertInputObjectType(schema.getType('ReviewInput'));
+	 * const fields = ReviewInput.getFields();
+	 *
+	 * Object.keys(fields); // => ['stars', 'commentary']
+	 * fields.commentary.default; // => { literal: { kind: 'StringValue', value: '' } }
+	 * ```
+	 */
+	getFields(): GraphQLInputFieldMap;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLInputObjectType,
+	 *   GraphQLInt,
+	 *   GraphQLNonNull,
+	 * } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {
+	 *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+	 *   },
+	 * });
+	 *
+	 * const config = ReviewInput.toConfig();
+	 * const ReviewInputCopy = new GraphQLInputObjectType(config);
+	 *
+	 * String(config.fields.stars.type); // => 'Int!'
+	 * String(ReviewInputCopy.getFields().stars.type); // => 'Int!'
+	 * ```
+	 */
+	toConfig(): GraphQLInputObjectTypeNormalizedConfig;
+	/**
+	 * Returns the schema coordinate identifying this input object type.
+	 * @returns The schema coordinate for this input object type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInputObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   input ReviewInput {
+	 *     stars: Int!
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(filter: ReviewInput): [String]
+	 *   }
+	 * `);
+	 *
+	 * const ReviewInput = assertInputObjectType(schema.getType('ReviewInput'));
+	 *
+	 * ReviewInput.toString(); // => 'ReviewInput'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The JSON-serializable representation.
+	 * @example
+	 * ```ts
+	 * import { GraphQLInputObjectType, GraphQLString } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {
+	 *     commentary: { type: GraphQLString },
+	 *   },
+	 * });
+	 *
+	 * ReviewInput.toJSON(); // => 'ReviewInput'
+	 * JSON.stringify({ type: ReviewInput }); // => '{"type":"ReviewInput"}'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/** Configuration used to construct a GraphQLInputObjectType. */
+export interface GraphQLInputObjectTypeConfig {
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Fields declared by this object, interface, input object, or literal. */
+	fields: ThunkObjMap<GraphQLInputFieldConfig>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLInputObjectTypeExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<InputObjectTypeDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<InputObjectTypeExtensionNode>>;
+	/** Whether this input object uses the experimental OneOf input object semantics. */
+	isOneOf?: boolean;
+}
+interface GraphQLInputObjectTypeNormalizedConfig extends GraphQLInputObjectTypeConfig {
+	fields: GraphQLInputFieldNormalizedConfigMap;
+	extensions: Readonly<GraphQLInputObjectTypeExtensions>;
+	extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLInputFieldExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL input field. */
+export interface GraphQLInputFieldConfig {
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLInputType;
+	/**
+	 * Deprecated legacy default value for this input field. Use `default`
+	 * instead.
+	 * @deprecated use `default` instead, `defaultValue` will be removed in v18
+	 */
+	defaultValue?: unknown;
+	/** Default value represented as either a runtime value or a GraphQL literal. */
+	default?: GraphQLDefaultInput | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason?: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLInputFieldExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<InputValueDefinitionNode>;
+}
+/** A map of input field names to input field configuration objects. */
+export type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;
+interface GraphQLInputFieldNormalizedConfig extends GraphQLInputFieldConfig {
+	default: GraphQLDefaultInput | undefined;
+	extensions: Readonly<GraphQLInputFieldExtensions>;
+}
+type GraphQLInputFieldNormalizedConfigMap = ObjMap<GraphQLInputFieldNormalizedConfig>;
+/** A resolved GraphQL input field definition. */
+export declare class GraphQLInputField implements GraphQLSchemaElement {
+	/** Input object type that owns this input field. */
+	parentType: GraphQLInputObjectType;
+	/** The GraphQL name for this schema element. */
+	name: string;
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	type: GraphQLInputType;
+	/**
+	 * Deprecated legacy default value used when no explicit value is supplied.
+	 * Use `default` instead.
+	 * @deprecated use `default` instead, `defaultValue` will be removed in v18
+	 */
+	defaultValue: unknown;
+	/** Default value represented as either a runtime value or a GraphQL literal. */
+	default: GraphQLDefaultInput | undefined;
+	/** Reason this element is deprecated, if one was provided. */
+	deprecationReason: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLInputFieldExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<InputValueDefinitionNode>;
+	/**
+	 * Creates a resolved GraphQL input field definition.
+	 * @param parentType - Input object type that owns this field.
+	 * @param name - Input field name.
+	 * @param config - Input field configuration.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLInputField,
+	 *   GraphQLInputObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {},
+	 * });
+	 * const field = new GraphQLInputField(ReviewInput, 'commentary', {
+	 *   type: GraphQLString,
+	 *   default: { value: '' },
+	 * });
+	 *
+	 * field.parentType; // => ReviewInput
+	 * field.name; // => 'commentary'
+	 * field.default.value; // => ''
+	 * ```
+	 */
+	constructor(parentType: GraphQLInputObjectType, name: string, config: GraphQLInputFieldConfig);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns a normalized configuration object for this input field.
+	 * @returns A configuration object that can be used to recreate this input field.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLInputField,
+	 *   GraphQLInputObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {},
+	 * });
+	 * const field = new GraphQLInputField(ReviewInput, 'commentary', {
+	 *   type: GraphQLString,
+	 *   extensions: { form: 'review' },
+	 * });
+	 *
+	 * field.toConfig().extensions; // => { form: 'review' }
+	 * ```
+	 */
+	toConfig(): GraphQLInputFieldNormalizedConfig;
+	/**
+	 * Returns this input field as a schema coordinate string.
+	 * @returns The input field coordinate.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLInputField,
+	 *   GraphQLInputObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {},
+	 * });
+	 * const field = new GraphQLInputField(ReviewInput, 'commentary', {
+	 *   type: GraphQLString,
+	 * });
+	 *
+	 * field.toString(); // => 'ReviewInput.commentary'
+	 * ```
+	 */
+	toString(): string;
+	/**
+	 * Returns the JSON representation used when this object is serialized.
+	 * @returns The input field coordinate.
+	 * @example
+	 * ```ts
+	 * import {
+	 *   GraphQLInputField,
+	 *   GraphQLInputObjectType,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const ReviewInput = new GraphQLInputObjectType({
+	 *   name: 'ReviewInput',
+	 *   fields: {},
+	 * });
+	 * const field = new GraphQLInputField(ReviewInput, 'commentary', {
+	 *   type: GraphQLString,
+	 * });
+	 *
+	 * JSON.stringify(field); // => '"ReviewInput.commentary"'
+	 * ```
+	 */
+	toJSON(): string;
+}
+/**
+ * Returns true when the input field is non-null and has no default value.
+ * @param field - The input field definition to inspect.
+ * @returns True when the input field is non-null and has no default value.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLInputField,
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ *   isRequiredInputField,
+ * } from 'graphql/type';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {},
+ * });
+ * const requiredField = new GraphQLInputField(ReviewInput, 'id', {
+ *   type: new GraphQLNonNull(GraphQLInt),
+ * });
+ * const optionalField = new GraphQLInputField(ReviewInput, 'name', {
+ *   type: GraphQLString,
+ * });
+ * const fieldWithDefault = new GraphQLInputField(ReviewInput, 'limit', {
+ *   type: new GraphQLNonNull(GraphQLInt),
+ *   default: { value: 10 },
+ * });
+ *
+ * isRequiredInputField(requiredField); // => true
+ * isRequiredInputField(optionalField); // => false
+ * isRequiredInputField(fieldWithDefault); // => false
+ * ```
+ */
+export declare function isRequiredInputField(field: GraphQLInputField): boolean;
+/** A map of input field names to resolved input field definitions. */
+export type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;
+/**
+ * Test if the given value is a GraphQL schema.
+ * @param schema - Value to inspect.
+ * @returns True when the value is a GraphQLSchema.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { GraphQLString, isSchema } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * isSchema(schema); // => true
+ * isSchema(GraphQLString); // => false
+ * ```
+ */
+export declare function isSchema(schema: unknown): schema is GraphQLSchema;
+/**
+ * Returns the value as a GraphQLSchema, or throws if it is not a schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The value typed as a GraphQLSchema.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertSchema, GraphQLString } from 'graphql/type';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * assertSchema(schema); // => schema
+ * assertSchema(GraphQLString); // throws an error
+ * ```
+ */
+export declare function assertSchema(schema: unknown): GraphQLSchema;
+/**
+ * Custom extensions
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+export interface GraphQLSchemaExtensions {
+	[attributeName: string | symbol]: unknown;
+}
+/**
+ * Schema Definition
+ *
+ * A 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.
+ * @example
+ * ```ts
+ * const MyAppQueryRootType = new GraphQLObjectType({
+ *   name: 'Query',
+ *   fields: {
+ *     greeting: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * const MyAppMutationRootType = new GraphQLObjectType({
+ *   name: 'Mutation',
+ *   fields: {
+ *     setGreeting: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * const MyAppSchema = new GraphQLSchema({
+ *   query: MyAppQueryRootType,
+ *   mutation: MyAppMutationRootType,
+ * });
+ * ```
+ * @example
+ * 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.
+ *
+ * ```ts
+ * const characterInterface = new GraphQLInterfaceType({
+ *   name: 'Character',
+ *   fields: {
+ *     name: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * const humanType = new GraphQLObjectType({
+ *   name: 'Human',
+ *   interfaces: [characterInterface],
+ *   fields: {
+ *     name: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * const droidType = new GraphQLObjectType({
+ *   name: 'Droid',
+ *   interfaces: [characterInterface],
+ *   fields: {
+ *     name: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       hero: { type: characterInterface },
+ *     },
+ *   }),
+ *   // Since this schema references only the `Character` interface it's
+ *   // necessary to explicitly list the types that implement it if
+ *   // you want them to be included in the final schema.
+ *   types: [humanType, droidType],
+ * });
+ * ```
+ * @example
+ * If an array of `directives` are provided to GraphQLSchema, that will be the
+ * exact list of directives represented and allowed. If `directives` is not
+ * provided then a default set of the specified directives (e.g. `@include` and
+ * `@skip`) will be used. If you wish to provide *additional* directives to
+ * these specified directives, you must explicitly declare them.
+ *
+ * ```ts
+ * const MyAppSchema = new GraphQLSchema({
+ *   query: MyAppQueryRootType,
+ *   directives: specifiedDirectives.concat([myCustomDirective]),
+ * });
+ * ```
+ */
+export declare class GraphQLSchema {
+	/** Human-readable description for this schema element, if provided. */
+	description: Maybe<string>;
+	/** Custom extension fields reserved for users. */
+	extensions: Readonly<GraphQLSchemaExtensions>;
+	/** AST node from which this schema element was built, if available. */
+	astNode: Maybe<SchemaDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes: ReadonlyArray<SchemaExtensionNode>;
+	/** Whether this schema instance skips validation checks. */
+	assumeValid: boolean;
+	private _queryType;
+	private _mutationType;
+	private _subscriptionType;
+	private _directives;
+	private _typeMap;
+	private _subTypeMap;
+	private _implementationsMap;
+	/**
+	 * Creates a GraphQLSchema instance.
+	 * @param config - Configuration describing this object.
+	 * @example
+	 * ```ts
+	 * // Create a schema with the required query root.
+	 * import { GraphQLObjectType, GraphQLSchema, GraphQLString } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({
+	 *   name: 'Query',
+	 *   fields: {
+	 *     greeting: {
+	 *       type: GraphQLString,
+	 *       resolve: () => 'Hello',
+	 *     },
+	 *   },
+	 * });
+	 *
+	 * const schema = new GraphQLSchema({
+	 *   description: 'The application schema.',
+	 *   query: Query,
+	 * });
+	 *
+	 * schema.getQueryType(); // => Query
+	 * schema.description; // => 'The application schema.'
+	 * ```
+	 * @example
+	 * ```ts
+	 * // This variant configures every schema option, including directives and extensions.
+	 * import { DirectiveLocation, parse } from 'graphql/language';
+	 * import {
+	 *   GraphQLBoolean,
+	 *   GraphQLDirective,
+	 *   GraphQLObjectType,
+	 *   GraphQLSchema,
+	 *   GraphQLString,
+	 * } from 'graphql/type';
+	 *
+	 * const Query = new GraphQLObjectType({
+	 *   name: 'Query',
+	 *   fields: { greeting: { type: GraphQLString } },
+	 * });
+	 * const Mutation = new GraphQLObjectType({
+	 *   name: 'Mutation',
+	 *   fields: { setGreeting: { type: GraphQLString } },
+	 * });
+	 * const Subscription = new GraphQLObjectType({
+	 *   name: 'Subscription',
+	 *   fields: { greetingChanged: { type: GraphQLString } },
+	 * });
+	 * const AuditEvent = new GraphQLObjectType({
+	 *   name: 'AuditEvent',
+	 *   fields: { message: { type: GraphQLString } },
+	 * });
+	 * const authDirective = new GraphQLDirective({
+	 *   name: 'auth',
+	 *   locations: [DirectiveLocation.FIELD_DEFINITION],
+	 *   args: { required: { type: GraphQLBoolean } },
+	 * });
+	 * const schemaDocument = parse(`
+	 *   schema {
+	 *     query: Query
+	 *     mutation: Mutation
+	 *     subscription: Subscription
+	 *   }
+	 *
+	 *   extend schema @auth
+	 * `);
+	 *
+	 * const schema = new GraphQLSchema({
+	 *   description: 'Operations exposed by the application.',
+	 *   query: Query,
+	 *   mutation: Mutation,
+	 *   subscription: Subscription,
+	 *   types: [AuditEvent],
+	 *   directives: [authDirective],
+	 *   extensions: { owner: 'platform' },
+	 *   astNode: schemaDocument.definitions[0],
+	 *   extensionASTNodes: [schemaDocument.definitions[1]],
+	 *   assumeValid: true,
+	 * });
+	 *
+	 * schema.getMutationType(); // => Mutation
+	 * schema.getSubscriptionType(); // => Subscription
+	 * schema.getType('AuditEvent'); // => AuditEvent
+	 * schema.getDirective('auth'); // => authDirective
+	 * schema.extensions; // => { owner: 'platform' }
+	 * ```
+	 */
+	constructor(config: Readonly<GraphQLSchemaConfig>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the root object type for query operations.
+	 * @returns The query root type, if this schema defines one.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 *
+	 * schema.getQueryType()?.name; // => 'Query'
+	 * ```
+	 */
+	getQueryType(): Maybe<GraphQLObjectType>;
+	/**
+	 * Returns the root object type for mutation operations.
+	 * @returns The mutation root type, if this schema defines one.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 *
+	 *   type Mutation {
+	 *     setGreeting(value: String!): String
+	 *   }
+	 * `);
+	 *
+	 * schema.getMutationType()?.name; // => 'Mutation'
+	 * ```
+	 */
+	getMutationType(): Maybe<GraphQLObjectType>;
+	/**
+	 * Returns the root object type for subscription operations.
+	 * @returns The subscription root type, if this schema defines one.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 *
+	 *   type Subscription {
+	 *     greetings: String
+	 *   }
+	 * `);
+	 *
+	 * schema.getSubscriptionType()?.name; // => 'Subscription'
+	 * ```
+	 */
+	getSubscriptionType(): Maybe<GraphQLObjectType>;
+	/**
+	 * Returns the root object type for the requested operation kind.
+	 * @param operation - Operation kind to resolve.
+	 * @returns The root object type for the operation kind, if this schema defines one.
+	 * @example
+	 * ```ts
+	 * import { OperationTypeNode } from 'graphql/language';
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 *
+	 *   type Mutation {
+	 *     setGreeting(value: String!): String
+	 *   }
+	 * `);
+	 *
+	 * schema.getRootType(OperationTypeNode.QUERY)?.name; // => 'Query'
+	 * schema.getRootType(OperationTypeNode.MUTATION)?.name; // => 'Mutation'
+	 * schema.getRootType(OperationTypeNode.SUBSCRIPTION); // => undefined
+	 * ```
+	 */
+	getRootType(operation: OperationTypeNode): Maybe<GraphQLObjectType>;
+	/**
+	 * Returns all named types known to this schema.
+	 * @returns A map of schema types keyed by type name.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type User {
+	 *     name: String
+	 *   }
+	 *
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 * `);
+	 *
+	 * const typeMap = schema.getTypeMap();
+	 *
+	 * typeMap.User.name; // => 'User'
+	 * typeMap.Query.name; // => 'Query'
+	 * typeMap.String.name; // => 'String'
+	 * ```
+	 */
+	getTypeMap(): TypeMap;
+	/**
+	 * Returns the named type with the provided name.
+	 * @param name - The GraphQL name to look up.
+	 * @returns The named schema type, if one exists.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type User {
+	 *     name: String
+	 *   }
+	 *
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 * `);
+	 *
+	 * schema.getType('User')?.toString(); // => 'User'
+	 * schema.getType('Missing'); // => undefined
+	 * ```
+	 */
+	getType(name: string): GraphQLNamedType | undefined;
+	/**
+	 * Returns object types that may be returned for an abstract type.
+	 * @param abstractType - Interface or union type to inspect.
+	 * @returns Object types that may satisfy the abstract type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType, assertUnionType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type User implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type Organization implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   union SearchResult = User | Organization
+	 *
+	 *   type Query {
+	 *     node: Node
+	 *     search: [SearchResult]
+	 *   }
+	 * `);
+	 *
+	 * const Node = assertInterfaceType(schema.getType('Node'));
+	 * const SearchResult = assertUnionType(schema.getType('SearchResult'));
+	 *
+	 * schema.getPossibleTypes(Node).map((type) => type.name); // => ['User', 'Organization']
+	 * schema.getPossibleTypes(SearchResult).map((type) => type.name); // => ['User', 'Organization']
+	 * ```
+	 */
+	getPossibleTypes(abstractType: GraphQLAbstractType): ReadonlyArray<GraphQLObjectType>;
+	/**
+	 * Returns objects and interfaces that implement an interface type.
+	 * @param interfaceType - Interface type to inspect.
+	 * @returns Object and interface implementations of the interface.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Resource {
+	 *     url: String!
+	 *   }
+	 *
+	 *   interface Image implements Resource {
+	 *     url: String!
+	 *     width: Int
+	 *   }
+	 *
+	 *   type Photo implements Resource & Image {
+	 *     url: String!
+	 *     width: Int
+	 *   }
+	 *
+	 *   type Query {
+	 *     resource: Resource
+	 *   }
+	 * `);
+	 *
+	 * const Resource = assertInterfaceType(schema.getType('Resource'));
+	 * const implementations = schema.getImplementations(Resource);
+	 *
+	 * implementations.interfaces.map((type) => type.name); // => ['Image']
+	 * implementations.objects.map((type) => type.name); // => ['Photo']
+	 * ```
+	 */
+	getImplementations(interfaceType: GraphQLInterfaceType): {
+		objects: ReadonlyArray<GraphQLObjectType>;
+		interfaces: ReadonlyArray<GraphQLInterfaceType>;
+	};
+	/**
+	 * Returns whether one type is a possible runtime subtype of an abstract type.
+	 * @param abstractType - Interface or union type to inspect.
+	 * @param maybeSubType - Object or interface type to test as a possible subtype.
+	 * @returns True when the subtype may satisfy the abstract type.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { assertInterfaceType, assertObjectType } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   interface Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type User implements Node {
+	 *     id: ID!
+	 *   }
+	 *
+	 *   type Review {
+	 *     body: String
+	 *   }
+	 *
+	 *   type Query {
+	 *     node: Node
+	 *     review: Review
+	 *   }
+	 * `);
+	 *
+	 * const Node = assertInterfaceType(schema.getType('Node'));
+	 * const User = assertObjectType(schema.getType('User'));
+	 * const Review = assertObjectType(schema.getType('Review'));
+	 *
+	 * schema.isSubType(Node, User); // => true
+	 * schema.isSubType(Node, Review); // => false
+	 * ```
+	 */
+	isSubType(abstractType: GraphQLAbstractType, maybeSubType: GraphQLObjectType | GraphQLInterfaceType): boolean;
+	/**
+	 * Returns directives available in this schema.
+	 * @returns Directives available in this schema.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   directive @upper on FIELD_DEFINITION
+	 *
+	 *   type Query {
+	 *     greeting: String @upper
+	 *   }
+	 * `);
+	 *
+	 * schema.getDirectives().map((directive) => directive.name); // => ['include', 'skip', 'deprecated', 'specifiedBy', 'oneOf', 'upper']
+	 * ```
+	 */
+	getDirectives(): ReadonlyArray<GraphQLDirective>;
+	/**
+	 * Returns the current directive definition.
+	 * @param name - The GraphQL name to look up.
+	 * @returns The current directive definition, if known.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   directive @upper on FIELD_DEFINITION
+	 *
+	 *   type Query {
+	 *     greeting: String @upper
+	 *   }
+	 * `);
+	 *
+	 * schema.getDirective('upper')?.name; // => 'upper'
+	 * schema.getDirective('missing'); // => undefined
+	 * ```
+	 */
+	getDirective(name: string): Maybe<GraphQLDirective>;
+	/**
+	 * This method looks up the field on the given type definition.
+	 * It has special casing for the three introspection fields, `__schema`,
+	 * `__type` and `__typename`.
+	 *
+	 * `__typename` is special because it can always be queried as a field, even
+	 * in situations where no other fields are allowed, like on a Union.
+	 *
+	 * `__schema` and `__type` could get automatically added to the query type,
+	 * but that would require mutating type definitions, which would cause issues.
+	 * @param parentType - Composite type to look up the field on.
+	 * @param fieldName - Field name to look up.
+	 * @returns The field definition, including supported introspection fields.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const queryType = schema.getQueryType();
+	 *
+	 * schema.getField(queryType, 'greeting')?.name; // => 'greeting'
+	 * schema.getField(queryType, '__typename')?.name; // => '__typename'
+	 * schema.getField(queryType, 'missing'); // => undefined
+	 * ```
+	 */
+	getField(parentType: GraphQLCompositeType, fieldName: string): GraphQLField<unknown, unknown> | undefined;
+	/**
+	 * Returns a normalized configuration object for this object.
+	 *
+	 * The returned config preserves the original `assumeValid` flag so the schema
+	 * can be recreated with the same validation behavior.
+	 * @returns A configuration object that can be used to recreate this object.
+	 * @example
+	 * ```ts
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { GraphQLSchema } from 'graphql/type';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 *
+	 * const config = schema.toConfig();
+	 * const schemaCopy = new GraphQLSchema(config);
+	 *
+	 * config.query?.name; // => 'Query'
+	 * schemaCopy.getQueryType()?.name; // => 'Query'
+	 * ```
+	 */
+	toConfig(): GraphQLSchemaNormalizedConfig;
+}
+type TypeMap = ObjMap<GraphQLNamedType>;
+interface GraphQLSchemaValidationOptions {
+	/**
+	 * When building a schema from a GraphQL service's introspection result, it
+	 * might be safe to assume the schema is valid. Set to true to assume the
+	 * produced schema is valid.
+	 *
+	 * Default: false
+	 *
+	 * @internal
+	 */
+	assumeValid?: boolean | undefined;
+}
+/** Configuration used to construct a GraphQLSchema. */
+export interface GraphQLSchemaConfig extends GraphQLSchemaValidationOptions {
+	/** Human-readable description for this schema element, if provided. */
+	description?: Maybe<string>;
+	/** Root object type for query operations. */
+	query?: Maybe<GraphQLObjectType>;
+	/** Root object type for mutation operations. */
+	mutation?: Maybe<GraphQLObjectType>;
+	/** Root object type for subscription operations. */
+	subscription?: Maybe<GraphQLObjectType>;
+	/** Object types that belong to this union type. */
+	types?: Maybe<ReadonlyArray<GraphQLNamedType>>;
+	/** Directives available in this schema or applied to this AST node. */
+	directives?: Maybe<ReadonlyArray<GraphQLDirective>>;
+	/** Custom extension fields reserved for users. */
+	extensions?: Maybe<Readonly<GraphQLSchemaExtensions>>;
+	/** AST node from which this schema element was built, if available. */
+	astNode?: Maybe<SchemaDefinitionNode>;
+	/** AST extension nodes applied to this schema element. */
+	extensionASTNodes?: Maybe<ReadonlyArray<SchemaExtensionNode>>;
+}
+interface GraphQLSchemaNormalizedConfig extends GraphQLSchemaConfig {
+	description: Maybe<string>;
+	types: ReadonlyArray<GraphQLNamedType>;
+	directives: ReadonlyArray<GraphQLDirective>;
+	extensions: Readonly<GraphQLSchemaExtensions>;
+	extensionASTNodes: ReadonlyArray<SchemaExtensionNode>;
+	assumeValid: boolean;
+}
+/**
+ * Error thrown when GraphQL execution is aborted.
+ * @typeParam TResult - Result value type.
+ */
+export declare class AbortedGraphQLExecutionError<TResult> extends Error {
+	/** Partial execution result available when execution was aborted. */
+	readonly abortedResult: PromiseOrValue<TResult>;
+	/**
+	 * Creates an error for an aborted GraphQL execution.
+	 * @param reason - Abort reason used as the error cause.
+	 * @param result - Partial execution result available when execution stopped.
+	 * @example
+	 * ```ts
+	 * import { AbortedGraphQLExecutionError } from 'graphql/execution';
+	 *
+	 * const cause = new Error('Request cancelled.');
+	 * const partialResult = { data: { viewer: null } };
+	 * const error = new AbortedGraphQLExecutionError(cause, partialResult);
+	 *
+	 * error.message; // => 'Request cancelled.'
+	 * error.cause; // => cause
+	 * error.abortedResult; // => partialResult
+	 * ```
+	 */
+	constructor(reason: unknown, result: PromiseOrValue<TResult>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+}
+/** Arguments accepted by execute and executeSync. */
+export interface ExecutionArgs {
+	/** The schema used for validation or execution. */
+	schema: GraphQLSchema;
+	/** The parsed GraphQL document to execute. */
+	document: DocumentNode;
+	/** Initial root value passed to the operation. */
+	rootValue?: unknown;
+	/** Application context value passed to every resolver. */
+	contextValue?: unknown;
+	/** Runtime variable values keyed by variable name. */
+	variableValues?: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Name of the operation to execute when the document contains multiple operations. */
+	operationName?: Maybe<string>;
+	/** Resolver used when a field does not define its own resolver. */
+	fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+	/** Resolver used when an abstract type does not define its own resolver. */
+	typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+	/** Resolver used for the root subscription field. */
+	subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+	/** Whether suggestion text should be omitted from request errors. */
+	hideSuggestions?: Maybe<boolean>;
+	/** AbortSignal used to cancel execution. */
+	abortSignal?: Maybe<AbortSignal>;
+	/** Whether incremental execution may begin eligible work early. */
+	enableEarlyExecution?: Maybe<boolean>;
+	/** Execution hooks invoked during this operation. */
+	hooks?: Maybe<ExecutionHooks>;
+	/** Additional execution options. */
+	options?: {
+		/**
+		 * Set the maximum number of errors allowed for coercing (defaults to 50).
+		 *
+		 * @internal
+		 */
+		maxCoercionErrors?: number;
+	};
+}
+/**
+ * Data that must be available at all points during query execution.
+ *
+ * Namely, schema of the type system that is currently executing,
+ * and the fragments defined in the query document
+ */
+export interface ValidatedExecutionArgs {
+	/** Schema used for execution. */
+	schema: GraphQLSchema;
+	/** Parsed GraphQL document being executed. */
+	document: DocumentNode;
+	/** Fragment definitions keyed by fragment name. */
+	fragmentDefinitions: ObjMap<FragmentDefinitionNode>;
+	/** Fragment details keyed by fragment name. */
+	fragments: ObjMap<FragmentDetails>;
+	/** Root value passed to the operation. */
+	rootValue: unknown;
+	/** Application context value passed to every resolver. */
+	contextValue: unknown;
+	/** Operation definition selected for execution. */
+	operation: OperationDefinitionNode;
+	/** Operation variable values with source metadata and coerced runtime values. */
+	variableValues: VariableValues;
+	/** Raw variable values provided by the caller before coercion. */
+	rawVariableValues: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Resolver used for fields without an explicit resolver. */
+	fieldResolver: GraphQLFieldResolver<any, any>;
+	/** Resolver used for abstract types without an explicit type resolver. */
+	typeResolver: GraphQLTypeResolver<any, any>;
+	/** Resolver used for subscription fields without an explicit subscribe resolver. */
+	subscribeFieldResolver: GraphQLFieldResolver<any, any>;
+	/** Whether suggestion text should be omitted from execution errors. */
+	hideSuggestions: boolean;
+	/** Whether execution should use error propagation. */
+	errorPropagation: boolean;
+	/** External signal that may abort execution. */
+	externalAbortSignal: AbortSignal | undefined;
+	/** Whether incremental execution may begin eligible work early. */
+	enableEarlyExecution: boolean;
+	/** Execution hooks supplied by the caller. */
+	hooks: ExecutionHooks | undefined;
+}
+/** Validated execution arguments for a subscription operation. */
+export interface ValidatedSubscriptionArgs extends ValidatedExecutionArgs {
+	/** Subscription operation definition selected for execution. */
+	operation: SubscriptionOperationDefinitionNode;
+}
+/** Information passed to hooks after asynchronous execution work has finished. */
+export interface AsyncWorkFinishedInfo {
+	/** Validated execution arguments for the operation that finished async work. */
+	validatedExecutionArgs: ValidatedExecutionArgs;
+}
+/** Optional hooks invoked during GraphQL execution. */
+export interface ExecutionHooks {
+	/** Called after all tracked asynchronous execution work has settled. */
+	asyncWorkFinished?: (info: AsyncWorkFinishedInfo) => void;
+}
+/**
+ * Represents the response produced by executing a GraphQL operation.
+ * @typeParam TData - Shape of the execution data payload.
+ * @typeParam TExtensions - Shape of the extensions payload.
+ */
+export interface ExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+	/** Errors raised while parsing, validating, or executing the operation. */
+	errors?: ReadonlyArray<GraphQLError>;
+	/** Data returned by execution, or null when execution could not produce data. */
+	data?: TData | null;
+	/** Additional non-standard metadata included in the execution result. */
+	extensions?: TExtensions;
+}
+/**
+ * A JSON-serializable GraphQL execution result.
+ * @typeParam TData - Shape of the formatted data payload.
+ * @typeParam TExtensions - Shape of the formatted extensions payload.
+ */
+export interface FormattedExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+	/** Errors raised while parsing, validating, or executing the operation. */
+	errors?: ReadonlyArray<GraphQLFormattedError>;
+	/** Data returned by execution, or null when execution could not produce data. */
+	data?: TData | null;
+	/** Additional non-standard metadata included in the formatted result. */
+	extensions?: TExtensions;
+}
+/**
+ * Results for an operation that produced incremental payloads.
+ * @typeParam TInitialData - Shape of the initial result data payload.
+ * @typeParam TDeferredData - Shape of deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface ExperimentalIncrementalExecutionResults<TInitialData = ObjMap<unknown>, TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Initial execution result delivered before subsequent incremental payloads. */
+	initialResult: InitialIncrementalExecutionResult<TInitialData, TExtensions>;
+	/** Async stream of incremental payloads delivered after the initial result. */
+	subsequentResults: AsyncGenerator<SubsequentIncrementalExecutionResult<TDeferredData, TStreamItem, TExtensions>, void, void>;
+}
+/**
+ * JSON-serializable form of incremental execution results.
+ * @typeParam TInitial - Shape of the formatted initial result data payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedExperimentalIncrementalExecutionResults<TInitial = ObjMap<unknown>, TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Formatted initial execution result. */
+	initialResult: FormattedInitialIncrementalExecutionResult<TInitial, TExtensions>;
+	/** Async stream of formatted incremental payloads. */
+	subsequentResults: AsyncGenerator<FormattedSubsequentIncrementalExecutionResult<TDeferredData, TStreamItem, TExtensions>, void, void>;
+}
+/**
+ * Initial execution result for an operation that produced incremental payloads.
+ * @typeParam TData - Shape of the initial data payload.
+ * @typeParam TExtensions - Shape of the extensions payload.
+ */
+export interface InitialIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends ExecutionResult<TData, TExtensions> {
+	/** Data produced by the initial execution payload. */
+	data: TData;
+	/** Incremental payloads that are still pending after the initial result. */
+	pending: ReadonlyArray<PendingResult>;
+	/** Indicates that subsequent incremental payloads will follow. */
+	hasNext: true;
+	/** Additional non-standard metadata included in the initial result. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of an initial incremental execution result.
+ * @typeParam TInitialData - Shape of the formatted initial data payload.
+ * @typeParam TExtensions - Shape of the formatted extensions payload.
+ */
+export interface FormattedInitialIncrementalExecutionResult<TInitialData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TInitialData, TExtensions> {
+	/** Formatted data produced by the initial execution payload. */
+	data: TInitialData;
+	/** Formatted list of incremental payloads still pending after the initial result. */
+	pending: ReadonlyArray<PendingResult>;
+	/** Indicates whether subsequent incremental payloads will follow. */
+	hasNext: boolean;
+	/** Additional non-standard metadata included in the formatted initial result. */
+	extensions?: TExtensions;
+}
+/**
+ * Subsequent payload produced by incremental execution.
+ * @typeParam TDeferredData - Shape of deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of the extensions payload.
+ */
+export interface SubsequentIncrementalExecutionResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Incremental payloads that became pending with this response. */
+	pending?: ReadonlyArray<PendingResult>;
+	/** Deferred or streamed payloads delivered by this response. */
+	incremental?: ReadonlyArray<IncrementalResult<TDeferredData, TStreamItem, TExtensions>>;
+	/** Incremental payloads that completed with this response. */
+	completed?: ReadonlyArray<CompletedResult>;
+	/** Indicates whether more incremental payloads will follow. */
+	hasNext: boolean;
+	/** Additional non-standard metadata included in this payload. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of a subsequent incremental execution payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedSubsequentIncrementalExecutionResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Indicates whether more incremental payloads will follow. */
+	hasNext: boolean;
+	/** Formatted incremental payloads that became pending with this response. */
+	pending?: ReadonlyArray<PendingResult>;
+	/** Formatted deferred or streamed payloads delivered by this response. */
+	incremental?: ReadonlyArray<FormattedIncrementalResult<TDeferredData, TStreamItem, TExtensions>>;
+	/** Formatted incremental payloads that completed with this response. */
+	completed?: ReadonlyArray<FormattedCompletedResult>;
+	/** Additional non-standard metadata included in this formatted payload. */
+	extensions?: TExtensions;
+}
+/**
+ * Incremental payload produced by a deferred fragment.
+ * @typeParam TDeferredData - Shape of deferred fragment data.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface IncrementalDeferResult<TDeferredData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+	/** Identifier matching this payload to a pending deferred fragment. */
+	id: string;
+	/** Path from the deferred fragment location to this payload. */
+	subPath?: ReadonlyArray<string | number>;
+	/** Errors raised while executing the deferred fragment. */
+	errors?: ReadonlyArray<GraphQLError>;
+	/** Data produced by the deferred fragment. */
+	data: TDeferredData;
+	/** Additional non-standard metadata included in this payload. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of a deferred fragment payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedIncrementalDeferResult<TDeferredData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+	/** Formatted errors raised while executing the deferred fragment. */
+	errors?: ReadonlyArray<GraphQLFormattedError>;
+	/** Formatted data produced by the deferred fragment. */
+	data: TDeferredData;
+	/** Identifier matching this payload to a pending deferred fragment. */
+	id: string;
+	/** Path from the deferred fragment location to this payload. */
+	subPath?: ReadonlyArray<string | number>;
+	/** Additional non-standard metadata included in this formatted payload. */
+	extensions?: TExtensions;
+}
+/**
+ * Incremental payload produced by a streamed list field.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface IncrementalStreamResult<TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Identifier matching this payload to a pending stream. */
+	id: string;
+	/** Path from the streamed field location to these items. */
+	subPath?: ReadonlyArray<string | number>;
+	/** Errors raised while producing streamed items. */
+	errors?: ReadonlyArray<GraphQLError>;
+	/** Streamed list items delivered by this payload. */
+	items: ReadonlyArray<TStreamItem>;
+	/** Additional non-standard metadata included in this payload. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of a streamed list payload.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedIncrementalStreamResult<TStreamItem = Array<unknown>, TExtensions = ObjMap<unknown>> {
+	/** Formatted errors raised while producing streamed items. */
+	errors?: ReadonlyArray<GraphQLFormattedError>;
+	/** Formatted streamed list items delivered by this payload. */
+	items: ReadonlyArray<TStreamItem>;
+	/** Identifier matching this payload to a pending stream. */
+	id: string;
+	/** Path from the streamed field location to these items. */
+	subPath?: ReadonlyArray<string | number>;
+	/** Additional non-standard metadata included in this formatted payload. */
+	extensions?: TExtensions;
+}
+/**
+ * Deferred fragment or streamed list payload produced by incremental execution.
+ * @typeParam TDeferredData - Shape of deferred fragment data.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export type IncrementalResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> = IncrementalDeferResult<TDeferredData, TExtensions> | IncrementalStreamResult<TStreamItem, TExtensions>;
+/**
+ * JSON-serializable deferred fragment or streamed list payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export type FormattedIncrementalResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> = FormattedIncrementalDeferResult<TDeferredData, TExtensions> | FormattedIncrementalStreamResult<TStreamItem, TExtensions>;
+interface PendingResult {
+	id: string;
+	path: ReadonlyArray<string | number>;
+	label?: string;
+}
+interface CompletedResult {
+	id: string;
+	errors?: ReadonlyArray<GraphQLError>;
+}
+interface FormattedCompletedResult {
+	id: string;
+	errors?: ReadonlyArray<GraphQLFormattedError>;
+}
+interface MinimalChannel<TMessage = unknown> {
+	readonly hasSubscribers?: boolean;
+	publish: (message: TMessage) => void;
+	runStores: <T, ContextType extends object>(context: ContextType, fn: (this: ContextType, ...args: Array<unknown>) => T, thisArg?: unknown, ...args: Array<unknown>) => T;
+}
+interface MinimalTracingChannel<TContext = unknown> {
+	readonly hasSubscribers: boolean | undefined;
+	readonly start: MinimalChannel<TContext>;
+	readonly end: MinimalChannel<TContext>;
+	readonly asyncStart: MinimalChannel<TContext>;
+	readonly asyncEnd: MinimalChannel<TContext>;
+	readonly error: MinimalChannel<TContext>;
+	traceSync: <T>(fn: (...args: Array<unknown>) => T, context: TContext extends object ? TContext : object, thisArg?: unknown, ...args: Array<unknown>) => T;
+}
+/** Context published on the sync-only `graphql:parse` channel. */
+export interface GraphQLParseContext {
+	/** Source text or source object passed to the parser. */
+	source: string | Source;
+	/** Error thrown while parsing, when parsing fails. */
+	error?: unknown;
+	/** Parsed document, when parsing succeeds. */
+	result?: DocumentNode;
+}
+/** Context published on the sync-only `graphql:validate` channel. */
+export interface GraphQLValidateContext {
+	/** Schema used for validation. */
+	schema: GraphQLSchema;
+	/** Parsed document being validated. */
+	document: DocumentNode;
+	/** Error thrown while validating, when validation fails abruptly. */
+	error?: unknown;
+	/** Validation errors returned by validation. */
+	result?: ReadonlyArray<GraphQLError>;
+}
+/**
+ * Context published on `graphql:execute`.
+ *
+ * Returned results may contain GraphQL errors collected during execution.
+ */
+export interface GraphQLExecuteContext {
+	/** Schema used for execution. */
+	schema: GraphQLSchema;
+	/** Parsed document being executed. */
+	document: DocumentNode;
+	/** Raw variable values provided by the caller before coercion. */
+	rawVariableValues: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Selected operation name, if one is available. */
+	operationName: string | undefined;
+	/** Selected operation type, if one is available. */
+	operationType: OperationTypeNode | undefined;
+	/** Error thrown or rejected while executing, when execution fails abruptly. */
+	error?: unknown;
+	/** Execution result returned by execution, including GraphQL errors. */
+	result?: ExecutionResult | ExperimentalIncrementalExecutionResults;
+}
+/**
+ * Context published on `graphql:execute:rootSelectionSet`.
+ *
+ * Returned results may contain GraphQL errors collected during execution.
+ */
+export interface GraphQLExecuteRootSelectionSetContext {
+	/** Schema used for execution. */
+	schema: GraphQLSchema;
+	/** Parsed document being executed. */
+	document: DocumentNode;
+	/** Operation definition selected for execution. */
+	operation: OperationDefinitionNode;
+	/** Raw variable values provided by the caller before coercion. */
+	rawVariableValues: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Selected operation name, if one is available. */
+	operationName: string | undefined;
+	/** Selected operation type. */
+	operationType: OperationTypeNode;
+	/** Error thrown or rejected while executing the root selection set. */
+	error?: unknown;
+	/**
+	 * Execution result returned from the root selection set, including GraphQL
+	 * errors.
+	 */
+	result?: ExecutionResult | ExperimentalIncrementalExecutionResults;
+}
+/**
+ * Context published on `graphql:execute:variableCoercion`.
+ *
+ * Coercion runs synchronously while execution arguments are validated, so only
+ * the `start`/`end` (and, on an abrupt throw, `error`) lifecycle fires.
+ * Ordinary variable coercion failures are returned on `result.errors`; when
+ * execution is invoked through APIs such as `execute()` or `subscribe()`, they
+ * surface as GraphQL result errors rather than as the tracing `error`
+ * lifecycle event.
+ */
+export interface GraphQLExecuteVariableCoercionContext {
+	/** Schema used for variable coercion. */
+	schema: GraphQLSchema;
+	/** Parsed document being executed. */
+	document: DocumentNode;
+	/** Operation definition whose variables are being coerced. */
+	operation: OperationDefinitionNode;
+	/** Raw variable values provided by the caller before coercion. */
+	rawVariableValues: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Selected operation name, if one is available. */
+	operationName: string | undefined;
+	/** Selected operation type. */
+	operationType: OperationTypeNode;
+	/** Error thrown while coercing variables, when coercion fails abruptly. */
+	error?: unknown;
+	/** Coerced variable values or coercion errors returned by coercion. */
+	result?: {
+		variableValues: VariableValues;
+	} | {
+		errors: ReadonlyArray<GraphQLError>;
+	};
+}
+/**
+ * Context published on `graphql:subscribe`.
+ *
+ * Subscription source resolver errors and invalid source stream results are
+ * returned on `result` as ExecutionResult errors; they do not publish the
+ * `error` lifecycle event unless subscription setup fails abruptly before
+ * GraphQL can form a result.
+ */
+export interface GraphQLSubscribeContext {
+	/** Schema used for subscription execution. */
+	schema: GraphQLSchema;
+	/** Parsed subscription document. */
+	document: DocumentNode;
+	/** Raw variable values provided by the caller before coercion. */
+	rawVariableValues: Maybe<{
+		readonly [variable: string]: unknown;
+	}>;
+	/** Selected operation name, if one is available. */
+	operationName: string | undefined;
+	/** Selected operation type, if one is available. */
+	operationType: OperationTypeNode | undefined;
+	/** Error thrown or rejected while subscribing, when setup fails abruptly. */
+	error?: unknown;
+	/**
+	 * Subscription response stream, or an ExecutionResult containing GraphQL
+	 * errors.
+	 */
+	result?: AsyncGenerator<ExecutionResult, void, void> | ExecutionResult;
+}
+/**
+ * Context published on `graphql:resolve`.
+ *
+ * Resolver throws and rejections publish the `error` lifecycle event here.
+ * The same failure may also be formatted into the enclosing execution or
+ * subscription result.
+ */
+export interface GraphQLResolveContext {
+	/** Field name being resolved. */
+	fieldName: string;
+	/** Response alias for the field being resolved. */
+	alias: string;
+	/** Parent type name for the field being resolved. */
+	parentType: string;
+	/** Return type string for the field being resolved. */
+	fieldType: string;
+	/** Argument values passed to the resolver. */
+	args: ObjMap<unknown>;
+	/** Whether the field is using the default resolver. */
+	isDefaultResolver: boolean;
+	/** Response path for the field being resolved. */
+	fieldPath: string;
+	/** Error thrown or rejected by the resolver, when resolution fails. */
+	error?: unknown;
+	/** Value returned by the resolver, when resolution succeeds. */
+	result?: unknown;
+}
+/** Mapping from tracing channel name to the context type published on it. */
+export interface GraphQLChannelContextByName {
+	/** Context published on `graphql:parse`. */
+	"graphql:parse": GraphQLParseContext;
+	/** Context published on `graphql:validate`. */
+	"graphql:validate": GraphQLValidateContext;
+	/** Context published on `graphql:execute`. */
+	"graphql:execute": GraphQLExecuteContext;
+	/** Context published on `graphql:execute:variableCoercion`. */
+	"graphql:execute:variableCoercion": GraphQLExecuteVariableCoercionContext;
+	/** Context published on `graphql:execute:rootSelectionSet`. */
+	"graphql:execute:rootSelectionSet": GraphQLExecuteRootSelectionSetContext;
+	/** Context published on `graphql:subscribe`. */
+	"graphql:subscribe": GraphQLSubscribeContext;
+	/** Context published on `graphql:resolve`. */
+	"graphql:resolve": GraphQLResolveContext;
+}
+/**
+ * The collection of tracing channels GraphQL.js emits on. Application
+ * performance monitoring (APM) tools subscribe to these by name on their own
+ * `node:diagnostics_channel` import; both paths land on the same channel
+ * instance because `tracingChannel(name)` is cached by name.
+ */
+export interface GraphQLChannels {
+	/** Tracing channel for `graphql:execute`. */
+	execute: MinimalTracingChannel<GraphQLExecuteContext>;
+	/** Tracing channel for `graphql:execute:variableCoercion`. */
+	executeVariableCoercion: MinimalTracingChannel<GraphQLExecuteVariableCoercionContext>;
+	/** Tracing channel for `graphql:execute:rootSelectionSet`. */
+	executeRootSelectionSet: MinimalTracingChannel<GraphQLExecuteRootSelectionSetContext>;
+	/** Tracing channel for `graphql:parse`. */
+	parse: MinimalTracingChannel<GraphQLParseContext>;
+	/** Tracing channel for `graphql:validate`. */
+	validate: MinimalTracingChannel<GraphQLValidateContext>;
+	/** Tracing channel for `graphql:resolve`. */
+	resolve: MinimalTracingChannel<GraphQLResolveContext>;
+	/** Tracing channel for `graphql:subscribe`. */
+	subscribe: MinimalTracingChannel<GraphQLSubscribeContext>;
+}
+interface LexerInterface {
+	source: Source;
+	lastToken: Token;
+	token: Token;
+	line: number;
+	lineStart: number;
+	advance: () => Token;
+	lookahead: () => Token;
+}
+/**
+ * Given a Source object, creates a Lexer for that source.
+ * A Lexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+export declare class Lexer implements LexerInterface {
+	/** Source document used to derive error locations. */
+	source: Source;
+	/** Most recent non-ignored token returned by the lexer. */
+	lastToken: Token;
+	/** Current non-ignored token at the lexer cursor. */
+	token: Token;
+	/** The (1-indexed) line containing the current token. */
+	line: number;
+	/** Character offset where the current line starts. */
+	lineStart: number;
+	/**
+	 * Creates a Lexer instance.
+	 * @param source - Source document used to derive error locations.
+	 * @example
+	 * ```ts
+	 * import { Lexer, Source, TokenKind } from 'graphql/language';
+	 *
+	 * const lexer = new Lexer(new Source('{ hello }'));
+	 *
+	 * lexer.token.kind; // => TokenKind.SOF
+	 * lexer.advance().kind; // => TokenKind.BRACE_L
+	 * lexer.advance().value; // => 'hello'
+	 * lexer.advance().kind; // => TokenKind.BRACE_R
+	 * ```
+	 */
+	constructor(source: Source);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Advances the token stream to the next non-ignored token.
+	 * @returns The next non-ignored token.
+	 * @example
+	 * ```ts
+	 * import { Lexer, Source } from 'graphql/language';
+	 *
+	 * const lexer = new Lexer(new Source('{ hello }'));
+	 * const token = lexer.advance();
+	 *
+	 * token.kind; // => '{'
+	 * lexer.token; // => token
+	 * ```
+	 */
+	advance(): Token;
+	/**
+	 * Looks ahead and returns the next non-ignored token, but does not change
+	 * the state of Lexer.
+	 * @returns The next non-ignored token without advancing the lexer.
+	 * @example
+	 * ```ts
+	 * import { Lexer, Source } from 'graphql/language';
+	 *
+	 * const lexer = new Lexer(new Source('{ hello }'));
+	 * const token = lexer.lookahead();
+	 *
+	 * token.kind; // => '{'
+	 * lexer.token.kind; // => '<SOF>'
+	 * ```
+	 */
+	lookahead(): Token;
+}
+/** Configuration options to control parser behavior */
+export interface ParseOptions {
+	/**
+	 * By default, the parser creates AST nodes that know the location
+	 * in the source that they correspond to. This configuration flag
+	 * disables that behavior for performance or testing.
+	 */
+	noLocation?: boolean | undefined;
+	/**
+	 * Parser CPU and memory usage is linear to the number of tokens in a document
+	 * however in extreme cases it becomes quadratic due to memory exhaustion.
+	 * Parsing happens before validation so even invalid queries can burn lots of
+	 * CPU time and memory.
+	 * To prevent this you can set a maximum number of tokens allowed within a document.
+	 */
+	maxTokens?: number | undefined;
+	/**
+	 * EXPERIMENTAL:
+	 *
+	 * If enabled, the parser will understand and parse fragment variable definitions
+	 * and arguments on fragment spreads. Fragment variable definitions will be represented
+	 * in the `variableDefinitions` field of the FragmentDefinitionNode.
+	 * Fragment spread arguments will be represented in the `arguments` field of FragmentSpreadNode.
+	 * @example
+	 * ```graphql prettier-ignore
+	 * {
+	 *   t { ...A(var: true) }
+	 * }
+	 * fragment A($var: Boolean = false) on T {
+	 *   ...B(x: $var)
+	 * }
+	 * ```
+	 */
+	experimentalFragmentArguments?: boolean | undefined;
+	/**
+	 * Internal parser hook for GraphQL.js entry points that need to parse a
+	 * restricted grammar with an alternate lexer.
+	 * @internal
+	 */
+	lexer?: LexerInterface | undefined;
+}
+/**
+ * Given a GraphQL source, parses it into a Document.
+ * Throws GraphQLError if a syntax error is encountered.
+ * @param source - A GraphQL source string or source object.
+ * @param options - Optional parser configuration.
+ * @returns The parsed GraphQL document AST.
+ * @example
+ * ```ts
+ * // Parse a GraphQL document with the default parser options.
+ * import { parse } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ *
+ * document.kind; // => 'Document'
+ * ```
+ * @example
+ * ```ts
+ * // This variant enables parser options and provides an explicit lexer.
+ * import { Lexer, Source, parse } from 'graphql/language';
+ *
+ * const document = parse(
+ *   `
+ *     {
+ *       t { ...A(var: true) }
+ *     }
+ *     fragment A($var: Boolean = false) on T {
+ *       name
+ *     }
+ *   `,
+ *   {
+ *     experimentalFragmentArguments: true,
+ *     maxTokens: 80,
+ *     noLocation: true,
+ *   },
+ * );
+ * const directiveDocument = parse('directive @foo @bar on FIELD');
+ * const source = new Source('{ hero }');
+ * const lexerDocument = parse(source, { lexer: new Lexer(source) });
+ *
+ * document.definitions[0].kind; // => 'OperationDefinition'
+ * document.definitions[1].kind; // => 'FragmentDefinition'
+ * document.loc; // => undefined
+ * directiveDocument.definitions[0].kind; // => 'DirectiveDefinition'
+ * lexerDocument.definitions[0].kind; // => 'OperationDefinition'
+ * ```
+ */
+export declare function parse(source: string | Source, options?: ParseOptions): DocumentNode;
+/**
+ * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
+ * that value.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * This is useful within tools that operate upon GraphQL Values directly and
+ * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: valueFromAST().
+ * @param source - A GraphQL source string or source object containing a value.
+ * @param options - Optional parser configuration.
+ * @returns The parsed GraphQL value AST.
+ * @example
+ * ```ts
+ * import { parseValue } from 'graphql/language';
+ *
+ * const value = parseValue('[42]');
+ *
+ * value.kind; // => 'ListValue'
+ * ```
+ */
+export declare function parseValue(source: string | Source, options?: ParseOptions): ValueNode;
+/**
+ * Similar to parseValue(), but raises a parse error if it encounters a
+ * variable. The return type will be a constant value.
+ * @param source - A GraphQL source string or source object containing a constant value.
+ * @param options - Optional parser configuration.
+ * @returns The parsed GraphQL constant value AST.
+ * @example
+ * ```ts
+ * import { parseConstValue } from 'graphql/language';
+ *
+ * const value = parseConstValue('{ enabled: true }');
+ *
+ * value.kind; // => 'ObjectValue'
+ * parseConstValue('$variable'); // throws an error
+ * ```
+ */
+export declare function parseConstValue(source: string | Source, options?: ParseOptions): ConstValueNode;
+/**
+ * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
+ * that type.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * This is useful within tools that operate upon GraphQL Types directly and
+ * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: typeFromAST().
+ * @param source - A GraphQL source string or source object containing a type reference.
+ * @param options - Optional parser configuration.
+ * @returns The parsed GraphQL type AST.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ *
+ * const type = parseType('[String!]');
+ *
+ * type.kind; // => 'ListType'
+ * ```
+ */
+export declare function parseType(source: string | Source, options?: ParseOptions): TypeNode;
+/**
+ * Given a string containing a GraphQL Schema Coordinate (ex. `Type.field`),
+ * parse the AST for that schema coordinate.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * Consider providing the results to the utility function:
+ * resolveASTSchemaCoordinate(). Or calling resolveSchemaCoordinate() directly
+ * with an unparsed source.
+ * @param source - A GraphQL source string or source object containing a schema coordinate.
+ * @returns The parsed GraphQL schema coordinate AST.
+ * @example
+ * ```ts
+ * import { parseSchemaCoordinate } from 'graphql/language';
+ *
+ * const coordinate = parseSchemaCoordinate('Query.hero');
+ *
+ * coordinate.kind; // => 'MemberCoordinate'
+ * ```
+ */
+export declare function parseSchemaCoordinate(source: string | Source): SchemaCoordinateNode;
+/** The set of allowed kind values for AST nodes. */
+export type Kind = (typeof Kind)[keyof typeof Kind];
+/** A visitor defines the callbacks called during AST traversal. */
+export 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;
+}
+/**
+ * A visitor is composed of visit functions called for each node during traversal.
+ * @typeParam TVisitedNode - AST node type handled by this visitor function.
+ */
+export type ASTVisitFn<TVisitedNode extends ASTNode> = (
+/** Current node being visited. */
+node: TVisitedNode, 
+/** Index or key for this node within the parent node or array. */
+key: string | number | undefined, 
+/** Parent immediately above this node, which may be an array. */
+parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 
+/** Key path from the root node to this node. */
+path: ReadonlyArray<string | number>, 
+/**
+ * All nodes and arrays visited before reaching this node's parent.
+ * These correspond to array indices in `path`.
+ * Note: ancestors includes arrays that contain the visited node's parent.
+ */
+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> = (
+/**
+ * Current node being visited.
+ * @internal
+ */
+node: {
+	[K in keyof TReducedNode]: ReducedField<TReducedNode[K], R>;
+}, 
+/**
+ * Index or key for this node within the parent node or array.
+ * @internal
+ */
+key: string | number | undefined, 
+/**
+ * Parent immediately above this node, which may be an array.
+ * @internal
+ */
+parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 
+/**
+ * Key path from the root node to this node.
+ * @internal
+ */
+path: ReadonlyArray<string | number>, 
+/**
+ * All nodes and arrays visited before reaching this node's parent.
+ * These correspond to array indices in `path`.
+ * Note: ancestors includes arrays that contain the visited node's parent.
+ * @internal
+ */
+ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => R;
+type ReducedField<T, R> = T extends ASTNode ? R : T extends ReadonlyArray<ASTNode> ? ReadonlyArray<R> : T;
+/** A visitor key map describes the traversable child properties for each node kind. */
+export type ASTVisitorKeyMap = {
+	[NodeT in ASTNode as NodeT["kind"]]?: ReadonlyArray<keyof NodeT>;
+};
+/** A value that can be returned from a visitor function to stop traversal. */
+export declare const BREAK: unknown;
+/**
+ * visit() will walk through an AST using a depth-first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ * @param root - The AST node at which to start traversal.
+ * @param visitor - The visitor or reducer functions to call while traversing.
+ * @param visitorKeys - Optional map of child keys to visit for each AST node kind.
+ * @returns The original AST, an edited AST, or a reduced value depending on the visitor.
+ * @typeParam N - The root AST node type returned when visiting without reducing.
+ * @example
+ * ```ts
+ * // Return values control traversal: undefined makes no change, false skips
+ * // a subtree, BREAK stops traversal, null removes a node, and any other
+ * // value replaces the current node.
+ * import { Kind, parse, print, visit } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * const editedAST = visit(document, {
+ *   Field: (node) => {
+ *     if (node.name.value === 'hero') {
+ *       return {
+ *         ...node,
+ *         name: { kind: Kind.NAME, value: 'human' },
+ *       };
+ *     }
+ *   },
+ * });
+ *
+ * print(editedAST); // => '{\n  human {\n    name\n  }\n}'
+ * ```
+ * @example
+ * ```ts
+ * // A named visitor function runs when entering nodes of that kind.
+ * import { parse, visit } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * const fieldNames = [];
+ *
+ * visit(document, {
+ *   Field: (node) => {
+ *     fieldNames.push(node.name.value);
+ *   },
+ * });
+ *
+ * fieldNames; // => ['hero', 'name']
+ * ```
+ * @example
+ * ```ts
+ * // A named visitor object can provide separate enter and leave handlers for
+ * // nodes of that kind.
+ * import { parse, visit } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * const events = [];
+ *
+ * visit(document, {
+ *   Field: {
+ *     enter: (node) => {
+ *       events.push(`enter:${node.name.value}`);
+ *     },
+ *     leave: (node) => {
+ *       events.push(`leave:${node.name.value}`);
+ *     },
+ *   },
+ * });
+ *
+ * events; // => ['enter:hero', 'enter:name', 'leave:name', 'leave:hero']
+ * ```
+ * @example
+ * ```ts
+ * // Generic enter and leave handlers run for every node.
+ * import { parse, visit } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * let enterCount = 0;
+ * let leaveCount = 0;
+ *
+ * visit(document, {
+ *   enter: (node) => {
+ *     enterCount += 1;
+ *   },
+ *   leave: (node) => {
+ *     leaveCount += 1;
+ *   },
+ * });
+ *
+ * enterCount; // => leaveCount
+ * enterCount > 0; // => true
+ * ```
+ */
+export declare function visit<N extends ASTNode>(root: N, visitor: ASTVisitor, visitorKeys?: ASTVisitorKeyMap): N;
+/**
+ * Traverses an AST with reducer callbacks and returns the reduced value.
+ * @param root - The AST node where traversal starts.
+ * @param visitor - Reducer callbacks to invoke during traversal.
+ * @param visitorKeys - Optional mapping of child keys for each AST node kind.
+ * @returns The value produced by the reducer visitor.
+ * @typeParam R - The value produced by reducer visitor callbacks.
+ * @example
+ * ```ts
+ * // A reducer visitor returns values from leave handlers to build a reduced
+ * // result instead of returning an edited AST.
+ * import { parse, visit } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * const printed = visit(document, {
+ *   Name: {
+ *     leave: (node) => {
+ *       return node.value;
+ *     },
+ *   },
+ *   Field: {
+ *     leave: (node) => {
+ *       return node.selectionSet == null
+ *         ? node.name
+ *         : `${node.name} { ${node.selectionSet} }`;
+ *     },
+ *   },
+ *   SelectionSet: {
+ *     leave: (node) => {
+ *       return node.selections.join(' ');
+ *     },
+ *   },
+ *   OperationDefinition: {
+ *     leave: (node) => {
+ *       return node.selectionSet;
+ *     },
+ *   },
+ *   Document: {
+ *     leave: (node) => {
+ *       return node.definitions.join('\n');
+ *     },
+ *   },
+ * });
+ *
+ * printed; // => 'hero { name }'
+ * ```
+ */
+export declare function visit<R>(root: ASTNode, visitor: ASTReducer<R>, visitorKeys?: ASTVisitorKeyMap): R;
+/**
+ * Creates a new visitor instance which delegates to many visitors to run in
+ * parallel. Each visitor will be visited for each node before moving on.
+ *
+ * If a prior visitor edits a node, no following visitors will see that node.
+ * @param visitors - The visitors to merge into one parallel visitor.
+ * @returns A visitor that delegates traversal to each provided visitor.
+ * @example
+ * ```ts
+ * import { parse, visit, visitInParallel } from 'graphql/language';
+ *
+ * const document = parse('{ hero { name } }');
+ * const events = [];
+ *
+ * visit(
+ *   document,
+ *   visitInParallel([
+ *     {
+ *       Field: (node) => {
+ *         events.push(`field:${node.name.value}`);
+ *       },
+ *     },
+ *     {
+ *       Name: (node) => {
+ *         events.push(`name:${node.value}`);
+ *       },
+ *     },
+ *   ]),
+ * );
+ *
+ * events; // => ['field:hero', 'name:hero', 'field:name', 'name:name']
+ * ```
+ */
+export declare function visitInParallel(visitors: ReadonlyArray<ASTVisitor>): ASTVisitor;
+/**
+ * Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.
+ * @param visitor - The visitor object to inspect.
+ * @param kind - The AST node kind to resolve handlers for.
+ * @returns The enter and leave handlers that apply for the given node kind.
+ * @example
+ * ```ts
+ * import { Kind, getEnterLeaveForKind } from 'graphql/language';
+ *
+ * const handlers = getEnterLeaveForKind({ Field: () => {} }, Kind.FIELD);
+ *
+ * typeof handlers.enter; // => 'function'
+ * handlers.leave; // => undefined
+ * ```
+ */
+export declare function getEnterLeaveForKind(visitor: ASTVisitor, kind: Kind): EnterLeaveVisitor<ASTNode>;
+interface FragmentSignature {
+	readonly definition: FragmentDefinitionNode;
+	readonly variableDefinitions: Map<string, VariableDefinitionNode>;
+}
+/**
+ * TypeInfo is a utility class which, given a GraphQL schema, can keep track
+ * of the current field and type definitions at any point in a GraphQL document
+ * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
+ */
+export declare class TypeInfo {
+	private _schema;
+	private _typeStack;
+	private _parentTypeStack;
+	private _inputTypeStack;
+	private _fieldDefStack;
+	private _defaultValueStack;
+	private _directive;
+	private _argument;
+	private _enumValue;
+	private _fragmentSignaturesByName;
+	private _fragmentSignature;
+	private _fragmentArgument;
+	/**
+	 * Creates a TypeInfo instance.
+	 * @param schema - Schema used for type lookups.
+	 * @param initialType - Optional type to use at the start of traversal.
+	 * @param fragmentSignatures - Fragment signatures available during traversal.
+	 * @example
+	 * ```ts
+	 * // Track field types during a visitWithTypeInfo traversal.
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema } from 'graphql/utilities';
+	 * import { TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * const seenTypes = [];
+	 *
+	 * visit(
+	 *   parse('{ greeting }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: () => {
+	 *       seenTypes.push(String(typeInfo.getType()));
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * seenTypes; // => ['String']
+	 * ```
+	 * @example
+	 * ```ts
+	 * // This variant starts from an initial type and supplies fragment signatures.
+	 * import { Kind, parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting(name: String): String
+	 *   }
+	 * `);
+	 * const fragmentDocument = parse(
+	 *   'fragment GreetingFields($name: String) on Query { greeting(name: $name) }',
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const fragmentDefinition = fragmentDocument.definitions[0];
+	 * const variableDefinition = fragmentDefinition.variableDefinitions[0];
+	 * const typeInfo = new TypeInfo(schema, schema.getQueryType(), (name) =>
+	 *   name === 'GreetingFields'
+	 *     ? {
+	 *         definition: fragmentDefinition,
+	 *         variableDefinitions: new Map([['name', variableDefinition]]),
+	 *       }
+	 *     : undefined,
+	 * );
+	 *
+	 * typeInfo.enter({
+	 *   kind: Kind.SELECTION_SET,
+	 *   selections: [],
+	 * });
+	 * typeInfo.enter({
+	 *   kind: Kind.FRAGMENT_SPREAD,
+	 *   name: { kind: Kind.NAME, value: 'GreetingFields' },
+	 *   arguments: [],
+	 *   directives: [],
+	 * });
+	 *
+	 * String(typeInfo.getParentType()); // => 'Query'
+	 * typeInfo.getFragmentSignature()?.definition.name.value; // => 'GreetingFields'
+	 * ```
+	 */
+	constructor(schema: GraphQLSchema, 
+	/**
+	 * Initial type may be provided in rare cases to facilitate traversals
+	 * beginning somewhere other than documents.
+	 */
+	initialType?: Maybe<GraphQLType>, fragmentSignatures?: Maybe<(fragmentName: string) => Maybe<FragmentSignature>>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns the current output type at this point in traversal.
+	 * @returns The current output type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 *
+	 *   type User {
+	 *     name: String
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * const fieldTypes = {};
+	 *
+	 * visit(
+	 *   parse('{ viewer { name } }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: (node) => {
+	 *       fieldTypes[node.name.value] = String(typeInfo.getType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fieldTypes; // => { viewer: 'User', name: 'String' }
+	 * ```
+	 */
+	getType(): Maybe<GraphQLOutputType>;
+	/**
+	 * Returns the current parent composite type.
+	 * @returns The current parent composite type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 *
+	 *   type User {
+	 *     name: String
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * const parentTypes = {};
+	 *
+	 * visit(
+	 *   parse('{ viewer { name } }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: (node) => {
+	 *       parentTypes[node.name.value] = String(typeInfo.getParentType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * parentTypes; // => { viewer: 'Query', name: 'User' }
+	 * ```
+	 */
+	getParentType(): Maybe<GraphQLCompositeType>;
+	/**
+	 * Returns the current input type at this point in traversal.
+	 * @returns The current input type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     reviews(stars: Int!, sort: Sort = NEWEST): [String]
+	 *   }
+	 *
+	 *   enum Sort {
+	 *     NEWEST
+	 *     OLDEST
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * const inputTypes = {};
+	 *
+	 * visit(
+	 *   parse('{ reviews(stars: 5, sort: OLDEST) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Argument: (node) => {
+	 *       inputTypes[node.name.value] = String(typeInfo.getInputType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * inputTypes; // => { stars: 'Int!', sort: 'Sort' }
+	 * ```
+	 */
+	getInputType(): Maybe<GraphQLInputType>;
+	/**
+	 * Returns the parent input type for the current input position.
+	 * @returns The parent input type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   input ReviewFilter {
+	 *     stars: Int!
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(filter: ReviewFilter): [String]
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * const parentInputTypes = {};
+	 *
+	 * visit(
+	 *   parse('{ reviews(filter: { stars: 5 }) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     ObjectField: (node) => {
+	 *       parentInputTypes[node.name.value] = String(typeInfo.getParentInputType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * parentInputTypes; // => { stars: 'ReviewFilter' }
+	 * ```
+	 */
+	getParentInputType(): Maybe<GraphQLInputType>;
+	/**
+	 * Returns the current field definition.
+	 * @returns The current field definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * let fieldName;
+	 *
+	 * visit(
+	 *   parse('{ greeting }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: () => {
+	 *       fieldName = typeInfo.getFieldDef()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fieldName; // => 'greeting'
+	 * ```
+	 */
+	getFieldDef(): Maybe<GraphQLField<unknown, unknown>>;
+	/**
+	 * Returns the default input representation for the current input position.
+	 * @returns The current default input, if one is available.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     reviews(limit: Int = 10): [String]
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * let defaultLimit;
+	 *
+	 * visit(
+	 *   parse('{ reviews(limit: 5) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Argument: () => {
+	 *       defaultLimit = typeInfo.getDefaultValue();
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * defaultLimit; // => { literal: { kind: 'IntValue', value: '10' } }
+	 * ```
+	 */
+	getDefaultValue(): unknown;
+	/**
+	 * Returns the current directive definition.
+	 * @returns The current directive definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * let directiveName;
+	 *
+	 * visit(
+	 *   parse('{ greeting @include(if: true) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Directive: () => {
+	 *       directiveName = typeInfo.getDirective()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * directiveName; // => 'include'
+	 * ```
+	 */
+	getDirective(): Maybe<GraphQLDirective>;
+	/**
+	 * Returns the current argument definition.
+	 * @returns The current argument definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     reviews(limit: Int = 10): [String]
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * let argumentName;
+	 *
+	 * visit(
+	 *   parse('{ reviews(limit: 5) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Argument: () => {
+	 *       argumentName = typeInfo.getArgument()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * argumentName; // => 'limit'
+	 * ```
+	 */
+	getArgument(): Maybe<GraphQLArgument>;
+	/**
+	 * Returns the current fragment signature.
+	 * @returns The fragment signature for the current fragment definition.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse(
+	 *   `
+	 *     {
+	 *       ...GreetingFields
+	 *     }
+	 *
+	 *     fragment GreetingFields on Query {
+	 *       greeting
+	 *     }
+	 *   `,
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const typeInfo = new TypeInfo(schema);
+	 * let fragmentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     FragmentSpread: () => {
+	 *       fragmentName = typeInfo.getFragmentSignature()?.definition.name.value;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fragmentName; // => 'GreetingFields'
+	 * ```
+	 */
+	getFragmentSignature(): Maybe<FragmentSignature>;
+	/**
+	 * Returns the function used to look up fragment signatures by name.
+	 * @returns A function that maps fragment names to fragment signatures.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse(
+	 *   `
+	 *     {
+	 *       ...GreetingFields
+	 *     }
+	 *
+	 *     fragment GreetingFields on Query {
+	 *       greeting
+	 *     }
+	 *   `,
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const typeInfo = new TypeInfo(schema);
+	 * let fragmentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Document: () => {
+	 *       const getFragmentSignature = typeInfo.getFragmentSignatureByName();
+	 *       fragmentName =
+	 *         getFragmentSignature('GreetingFields')?.definition.name.value;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fragmentName; // => 'GreetingFields'
+	 * ```
+	 */
+	getFragmentSignatureByName(): (fragmentName: string) => Maybe<FragmentSignature>;
+	/**
+	 * Returns the current fragment argument definition.
+	 * @returns The variable definition for the current fragment argument.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting(name: String): String
+	 *   }
+	 * `);
+	 * const document = parse(
+	 *   `
+	 *     {
+	 *       ...GreetingFields(name: "Ada")
+	 *     }
+	 *
+	 *     fragment GreetingFields($name: String) on Query {
+	 *       greeting(name: $name)
+	 *     }
+	 *   `,
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const typeInfo = new TypeInfo(schema);
+	 * let argumentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     FragmentArgument: () => {
+	 *       argumentName = typeInfo.getFragmentArgument()?.variable.name.value;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * argumentName; // => 'name'
+	 * ```
+	 */
+	getFragmentArgument(): Maybe<VariableDefinitionNode>;
+	/**
+	 * Returns the current enum value definition.
+	 * @returns The current enum value definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   enum Sort {
+	 *     NEWEST
+	 *     OLDEST
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(sort: Sort = NEWEST): [String]
+	 *   }
+	 * `);
+	 * const typeInfo = new TypeInfo(schema);
+	 * let enumValueName;
+	 *
+	 * visit(
+	 *   parse('{ reviews(sort: OLDEST) }'),
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     EnumValue: () => {
+	 *       enumValueName = typeInfo.getEnumValue()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * enumValueName; // => 'OLDEST'
+	 * ```
+	 */
+	getEnumValue(): Maybe<GraphQLEnumValue>;
+	/**
+	 * Updates this TypeInfo instance for an entered AST node.
+	 * @param node - AST node being entered.
+	 * @returns Nothing.
+	 * @example
+	 * ```ts
+	 * import { Kind, parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const operation = document.definitions[0];
+	 * const selectionSet = operation.selectionSet;
+	 * const field = selectionSet.selections[0];
+	 * const typeInfo = new TypeInfo(schema);
+	 *
+	 * typeInfo.enter(operation);
+	 * typeInfo.enter(selectionSet);
+	 * typeInfo.enter(field);
+	 *
+	 * field.kind; // => Kind.FIELD
+	 * typeInfo.getParentType()?.name; // => 'Query'
+	 * String(typeInfo.getType()); // => 'String'
+	 * ```
+	 */
+	enter(node: ASTNode): void;
+	/**
+	 * Updates this TypeInfo instance for a left AST node.
+	 * @param node - AST node being entered.
+	 * @returns Nothing.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const operation = document.definitions[0];
+	 * const selectionSet = operation.selectionSet;
+	 * const field = selectionSet.selections[0];
+	 * const typeInfo = new TypeInfo(schema);
+	 *
+	 * typeInfo.enter(operation);
+	 * typeInfo.enter(selectionSet);
+	 * typeInfo.enter(field);
+	 * String(typeInfo.getType()); // => 'String'
+	 *
+	 * typeInfo.leave(field);
+	 * typeInfo.getType(); // => undefined
+	 * ```
+	 */
+	leave(node: ASTNode): void;
+}
+/**
+ * Creates a new visitor instance which maintains a provided TypeInfo instance
+ * along with visiting visitor.
+ * @param typeInfo - TypeInfo instance to update during traversal.
+ * @param visitor - Visitor callbacks to wrap with TypeInfo updates.
+ * @returns A visitor that keeps TypeInfo in sync while delegating callbacks.
+ * @example
+ * ```ts
+ * import { parse, visit } from 'graphql/language';
+ * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const typeInfo = new TypeInfo(schema);
+ * const fields = [];
+ *
+ * visit(
+ *   parse('{ greeting }'),
+ *   visitWithTypeInfo(typeInfo, {
+ *     Field: (node) => {
+ *       fields.push({
+ *         name: node.name.value,
+ *         parentType: String(typeInfo.getParentType()),
+ *         type: String(typeInfo.getType()),
+ *       });
+ *     },
+ *   }),
+ * );
+ *
+ * fields; // => [{ name: 'greeting', parentType: 'Query', type: 'String' }]
+ * ```
+ */
+export declare function visitWithTypeInfo(typeInfo: TypeInfo, visitor: ASTVisitor): ASTVisitor;
+type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode;
+interface VariableUsage {
+	readonly node: VariableNode;
+	readonly type: Maybe<GraphQLInputType>;
+	readonly parentType: Maybe<GraphQLInputType>;
+	readonly defaultValue: unknown;
+	readonly fragmentVariableDefinition: Maybe<VariableDefinitionNode>;
+}
+declare class ASTValidationContext {
+	private _ast;
+	private _onError;
+	private _fragments;
+	private _fragmentSpreads;
+	private _recursivelyReferencedFragments;
+	constructor(ast: DocumentNode, onError: (error: GraphQLError) => void);
+	get [Symbol.toStringTag](): string;
+	reportError(error: GraphQLError): void;
+	getDocument(): DocumentNode;
+	getFragment(name: string): Maybe<FragmentDefinitionNode>;
+	getFragmentSpreads(node: SelectionSetNode): ReadonlyArray<FragmentSpreadNode>;
+	getRecursivelyReferencedFragments(operation: OperationDefinitionNode): ReadonlyArray<FragmentDefinitionNode>;
+}
+declare class SDLValidationContext extends ASTValidationContext {
+	private _schema;
+	constructor(ast: DocumentNode, schema: Maybe<GraphQLSchema>, onError: (error: GraphQLError) => void);
+	get hideSuggestions(): boolean;
+	get [Symbol.toStringTag](): string;
+	getSchema(): Maybe<GraphQLSchema>;
+}
+/** Validation context passed to query validation rules. */
+export declare class ValidationContext extends ASTValidationContext {
+	private _schema;
+	private _typeInfo;
+	private _variableUsages;
+	private _recursiveVariableUsages;
+	private _hideSuggestions;
+	/**
+	 * Creates a ValidationContext instance.
+	 * @param schema - Schema used to validate the document.
+	 * @param ast - Document AST being validated.
+	 * @param typeInfo - TypeInfo instance used to track traversal state.
+	 * @param onError - Callback invoked for each validation error.
+	 * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { GraphQLError } from 'graphql/error';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const errors = [];
+	 * const context = new ValidationContext(
+	 *   schema,
+	 *   document,
+	 *   new TypeInfo(schema),
+	 *   (error) => errors.push(error),
+	 * );
+	 *
+	 * context.reportError(new GraphQLError('Example validation error.'));
+	 *
+	 * context.getSchema(); // => schema
+	 * errors[0].message; // => 'Example validation error.'
+	 * ```
+	 */
+	constructor(schema: GraphQLSchema, ast: DocumentNode, typeInfo: TypeInfo, onError: (error: GraphQLError) => void, hideSuggestions?: Maybe<boolean>);
+	/**
+	 * Returns the value used by `Object.prototype.toString`.
+	 * @returns The built-in string tag for this object.
+	 */
+	get [Symbol.toStringTag](): string;
+	/**
+	 * Returns whether validation error suggestions are hidden.
+	 * @returns True when suggestion text should be omitted from errors.
+	 */
+	get hideSuggestions(): boolean;
+	/**
+	 * Returns the schema being used by this validation context.
+	 * @returns The schema being validated against.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const context = new ValidationContext(
+	 *   schema,
+	 *   parse('{ greeting }'),
+	 *   new TypeInfo(schema),
+	 *   () => {},
+	 * );
+	 *
+	 * context.getSchema().getQueryType()?.name; // => 'Query'
+	 * ```
+	 */
+	getSchema(): GraphQLSchema;
+	/**
+	 * Returns variable usages found directly within this node.
+	 * @param node - The AST node to inspect or visit.
+	 * @returns Variable usages found directly within this node.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting(name: String): String
+	 *   }
+	 * `);
+	 * const document = parse('query ($name: String) { greeting(name: $name) }');
+	 * const operation = document.definitions[0];
+	 * const context = new ValidationContext(
+	 *   schema,
+	 *   document,
+	 *   new TypeInfo(schema),
+	 *   () => {},
+	 * );
+	 *
+	 * const usages = context.getVariableUsages(operation);
+	 *
+	 * usages[0].node.name.value; // => 'name'
+	 * String(usages[0].type); // => 'String'
+	 * ```
+	 */
+	getVariableUsages(node: NodeWithSelectionSet): ReadonlyArray<VariableUsage>;
+	/**
+	 * Returns variable usages for an operation, including variables used by referenced fragments.
+	 * @param operation - Operation definition to inspect.
+	 * @returns Variable usages reachable from the operation.
+	 * @example
+	 * ```ts
+	 * import { parse } from 'graphql/language';
+	 * import { buildSchema, TypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     viewer: User
+	 *   }
+	 *
+	 *   type User {
+	 *     name(prefix: String): String
+	 *   }
+	 * `);
+	 * const document = parse(`
+	 *   query ($prefix: String) {
+	 *     viewer {
+	 *       ...UserName
+	 *     }
+	 *   }
+	 *
+	 *   fragment UserName on User {
+	 *     name(prefix: $prefix)
+	 *   }
+	 * `);
+	 * const operation = document.definitions[0];
+	 * const context = new ValidationContext(
+	 *   schema,
+	 *   document,
+	 *   new TypeInfo(schema),
+	 *   () => {},
+	 * );
+	 *
+	 * const usages = context.getRecursiveVariableUsages(operation);
+	 *
+	 * usages.map((usage) => usage.node.name.value); // => ['prefix']
+	 * ```
+	 */
+	getRecursiveVariableUsages(operation: OperationDefinitionNode): ReadonlyArray<VariableUsage>;
+	/**
+	 * Returns the current output type at this point in traversal.
+	 * @returns The current output type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let typeName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: () => {
+	 *       typeName = String(context.getType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * typeName; // => 'String'
+	 * ```
+	 */
+	getType(): Maybe<GraphQLOutputType>;
+	/**
+	 * Returns the current parent composite type.
+	 * @returns The current parent composite type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let parentTypeName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: () => {
+	 *       parentTypeName = context.getParentType()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * parentTypeName; // => 'Query'
+	 * ```
+	 */
+	getParentType(): Maybe<GraphQLCompositeType>;
+	/**
+	 * Returns the current input type at this point in traversal.
+	 * @returns The current input type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     reviews(limit: Int): [String]
+	 *   }
+	 * `);
+	 * const document = parse('{ reviews(limit: 5) }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let inputTypeName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Argument: () => {
+	 *       inputTypeName = String(context.getInputType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * inputTypeName; // => 'Int'
+	 * ```
+	 */
+	getInputType(): Maybe<GraphQLInputType>;
+	/**
+	 * Returns the parent input type for the current input position.
+	 * @returns The parent input type, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   input ReviewFilter {
+	 *     stars: Int
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(filter: ReviewFilter): [String]
+	 *   }
+	 * `);
+	 * const document = parse('{ reviews(filter: { stars: 5 }) }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let parentInputTypeName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     ObjectField: () => {
+	 *       parentInputTypeName = String(context.getParentInputType());
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * parentInputTypeName; // => 'ReviewFilter'
+	 * ```
+	 */
+	getParentInputType(): Maybe<GraphQLInputType>;
+	/**
+	 * Returns the current field definition.
+	 * @returns The current field definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let fieldName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Field: () => {
+	 *       fieldName = context.getFieldDef()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fieldName; // => 'greeting'
+	 * ```
+	 */
+	getFieldDef(): Maybe<GraphQLField<unknown, unknown>>;
+	/**
+	 * Returns the current directive definition.
+	 * @returns The current directive definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse('{ greeting @include(if: true) }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let directiveName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Directive: () => {
+	 *       directiveName = context.getDirective()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * directiveName; // => 'include'
+	 * ```
+	 */
+	getDirective(): Maybe<GraphQLDirective>;
+	/**
+	 * Returns the current argument definition.
+	 * @returns The current argument definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     reviews(limit: Int): [String]
+	 *   }
+	 * `);
+	 * const document = parse('{ reviews(limit: 5) }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let argumentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Argument: () => {
+	 *       argumentName = context.getArgument()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * argumentName; // => 'limit'
+	 * ```
+	 */
+	getArgument(): Maybe<GraphQLArgument>;
+	/**
+	 * Returns the fragment signature at the current traversal position.
+	 * @returns The current fragment signature, if one is active.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse(
+	 *   `
+	 *     {
+	 *       ...GreetingFields
+	 *     }
+	 *
+	 *     fragment GreetingFields on Query {
+	 *       greeting
+	 *     }
+	 *   `,
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let fragmentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     FragmentSpread: () => {
+	 *       fragmentName = context.getFragmentSignature()?.definition.name.value;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fragmentName; // => 'GreetingFields'
+	 * ```
+	 */
+	getFragmentSignature(): Maybe<FragmentSignature>;
+	/**
+	 * Returns the function used to look up fragment signatures by name.
+	 * @returns A function that maps fragment names to fragment signatures.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   type Query {
+	 *     greeting: String
+	 *   }
+	 * `);
+	 * const document = parse(
+	 *   `
+	 *     {
+	 *       ...GreetingFields
+	 *     }
+	 *
+	 *     fragment GreetingFields on Query {
+	 *       greeting
+	 *     }
+	 *   `,
+	 *   { experimentalFragmentArguments: true },
+	 * );
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let fragmentName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     Document: () => {
+	 *       const getFragmentSignature = context.getFragmentSignatureByName();
+	 *       fragmentName =
+	 *         getFragmentSignature('GreetingFields')?.definition.name.value;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * fragmentName; // => 'GreetingFields'
+	 * ```
+	 */
+	getFragmentSignatureByName(): (fragmentName: string) => Maybe<FragmentSignature>;
+	/**
+	 * Returns the current enum value definition.
+	 * @returns The current enum value definition, if known.
+	 * @example
+	 * ```ts
+	 * import { parse, visit } from 'graphql/language';
+	 * import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
+	 * import { ValidationContext } from 'graphql/validation';
+	 *
+	 * const schema = buildSchema(`
+	 *   enum Sort {
+	 *     NEWEST
+	 *     OLDEST
+	 *   }
+	 *
+	 *   type Query {
+	 *     reviews(sort: Sort): [String]
+	 *   }
+	 * `);
+	 * const document = parse('{ reviews(sort: OLDEST) }');
+	 * const typeInfo = new TypeInfo(schema);
+	 * const context = new ValidationContext(schema, document, typeInfo, () => {});
+	 * let enumValueName;
+	 *
+	 * visit(
+	 *   document,
+	 *   visitWithTypeInfo(typeInfo, {
+	 *     EnumValue: () => {
+	 *       enumValueName = context.getEnumValue()?.name;
+	 *     },
+	 *   }),
+	 * );
+	 *
+	 * enumValueName; // => 'OLDEST'
+	 * ```
+	 */
+	getEnumValue(): Maybe<GraphQLEnumValue>;
+}
+/** A function that creates an AST visitor for validating a GraphQL document. */
+export type ValidationRule = (context: ValidationContext) => ASTVisitor;
+/**
+ * Options used when validating a GraphQL document.
+ * @category Validation
+ */
+export interface ValidationOptions {
+	/** Maximum number of validation errors before validation stops. */
+	maxErrors?: number;
+	/** Whether suggestion text should be omitted from validation errors. */
+	hideSuggestions?: Maybe<boolean>;
+}
+/**
+ * Implements the "Validation" section of the spec.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the document is valid.
+ *
+ * A list of specific validation rules may be provided. If not provided, the
+ * default list of rules defined by the GraphQL specification will be used.
+ *
+ * Each validation rule is a function that returns a visitor
+ * (see the language/visitor API). Visitor methods are expected to return
+ * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+ *
+ * Validate will stop validation after a `maxErrors` limit has been reached.
+ * Attackers can send pathologically invalid queries to induce a DoS attack,
+ * so `maxErrors` defaults to 100 errors.
+ * @param schema - Schema to validate against.
+ * @param documentAST - Document AST to validate.
+ * @param rules - Validation rules to apply.
+ * @param options - Validation options, including error limits and suggestions.
+ * @returns Validation errors, or an empty array when the document is valid.
+ * @example
+ * ```ts
+ * // Validate with the default specified rules.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validate } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     fullName: String
+ *   }
+ * `);
+ *
+ * validate(schema, parse('{ greeting }')); // => []
+ *
+ * const errors = validate(schema, parse('{ missing }'));
+ * errors[0].message; // => 'Cannot query field "missing" on type "Query".'
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses a custom rule list and validation options.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { FieldsOnCorrectTypeRule, validate } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const document = parse('{ missingOne missingTwo }');
+ *
+ * const errors = validate(schema, document, [FieldsOnCorrectTypeRule], {
+ *   maxErrors: 1,
+ * });
+ *
+ * errors.length; // => 2
+ * errors[1].message; // => 'Too many validation errors, error limit reached. Validation aborted.'
+ *
+ * const hiddenSuggestionErrors = validate(
+ *   schema,
+ *   parse('{ name }'),
+ *   [FieldsOnCorrectTypeRule],
+ *   { hideSuggestions: true },
+ * );
+ *
+ * hiddenSuggestionErrors[0].message; // => 'Cannot query field "name" on type "Query".'
+ * ```
+ */
+export declare function validate(schema: GraphQLSchema, documentAST: DocumentNode, rules?: ReadonlyArray<ValidationRule>, options?: ValidationOptions): ReadonlyArray<GraphQLError>;
+/** Function used to execute a validated root selection set for a subscription event. */
+export type RootSelectionSetExecutor = (validatedExecutionArgs: ValidatedSubscriptionArgs) => PromiseOrValue<ExecutionResult>;
+/**
+ * Implements the "Executing requests" section of the GraphQL specification.
+ *
+ * Returns either a synchronous ExecutionResult (if all encountered resolvers
+ * are synchronous), or a Promise of an ExecutionResult that will eventually be
+ * resolved and never rejected.
+ *
+ * If the schema is invalid, an error will be thrown immediately. GraphQL
+ * request errors, including missing operations and variable coercion errors,
+ * are returned in an errors-only ExecutionResult.
+ *
+ * Field errors are collected into the response instead of rejecting the
+ * returned promise. Only the field that produced the error and its descendants
+ * are omitted; sibling fields continue to execute. Errors from fields of
+ * non-null type may propagate to the nearest nullable parent, which can be the
+ * entire response data.
+ *
+ * This function does not support incremental delivery (`@defer` and `@stream`).
+ * Use `experimentalExecuteIncrementally` to execute operations with
+ * incremental delivery enabled.
+ * @param args - The arguments used to perform the operation.
+ * @returns A completed execution result, or a promise resolving to one when execution is asynchronous.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { execute } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting(name: String!): String
+ *   }
+ * `);
+ *
+ * const result = await execute({
+ *   schema,
+ *   document: parse('query ($name: String!) { greeting(name: $name) }'),
+ *   rootValue: {
+ *     greeting: ({ name }) => `Hello, ${name}!`,
+ *   },
+ *   variableValues: { name: 'Ada' },
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello, Ada!' } }
+ * ```
+ */
+export declare function execute(args: ExecutionArgs): PromiseOrValue<ExecutionResult>;
+/**
+ * Implements the "Executing requests" section of the GraphQL specification,
+ * including `@defer` and `@stream` as proposed in
+ * https://github.com/graphql/graphql-spec/pull/742
+ *
+ * This function returns either a single ExecutionResult, or an
+ * ExperimentalIncrementalExecutionResults object containing an `initialResult`
+ * and a stream of `subsequentResults`.
+ *
+ * If the schema is invalid, an error will be thrown immediately. GraphQL
+ * request errors, including missing operations and variable coercion errors,
+ * are returned in an errors-only ExecutionResult.
+ * @param args - Execution arguments for the GraphQL operation.
+ * @returns A single execution result or incremental execution results.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { experimentalExecuteIncrementally } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const result = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ * @category Incremental Execution
+ */
+export declare function experimentalExecuteIncrementally(args: ExecutionArgs): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults>;
+/**
+ * Implements the "Executing operations" section of the spec.
+ *
+ * Returns either a synchronous ExecutionResult, or a Promise for an
+ * ExecutionResult, described by the "Response" section of the GraphQL
+ * specification.
+ *
+ * If errors are encountered while executing a GraphQL field, only that field
+ * and its descendants will be omitted, and sibling fields will still be
+ * executed. These field errors are collected into the returned result instead
+ * of being thrown or rejecting the returned promise.
+ *
+ * Errors from sub-fields of a NonNull type may propagate to the top level, at
+ * which point we still collect the error and null the parent field, which in
+ * this case is the entire response.
+ * @param validatedExecutionArgs - Validated execution arguments.
+ * @returns Execution result for the operation root selection set.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   executeRootSelectionSet,
+ *   validateExecutionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await executeRootSelectionSet(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function executeRootSelectionSet(validatedExecutionArgs: ValidatedExecutionArgs): PromiseOrValue<ExecutionResult>;
+/**
+ * Executes the operation root selection set with incremental delivery enabled.
+ * @param validatedExecutionArgs - Validated execution arguments.
+ * @returns A single execution result or incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteRootSelectionSet,
+ *   validateExecutionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await experimentalExecuteRootSelectionSet(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ * @category Incremental Execution
+ */
+export declare function experimentalExecuteRootSelectionSet(validatedExecutionArgs: ValidatedExecutionArgs): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults>;
+/**
+ * Also implements the "Executing requests" section of the GraphQL specification.
+ * However, it guarantees to complete synchronously (or throw an error) assuming
+ * that all field resolvers are also synchronous.
+ * @param args - The arguments used to perform the operation.
+ * @returns Completed execution output for a synchronous operation.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { executeSync } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ *
+ * const result = executeSync({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function executeSync(args: ExecutionArgs): ExecutionResult;
+/**
+ * Executes a subscription operation once for a single source event.
+ *
+ * Field errors are collected into the returned result instead of being thrown
+ * or rejecting the returned promise.
+ * @param validatedExecutionArgs - Validated subscription execution arguments.
+ * @returns Execution result for the subscription event.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   executeSubscriptionEvent,
+ *   validateSubscriptionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ * const validatedArgs = validateSubscriptionArgs({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await executeSubscriptionEvent(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function executeSubscriptionEvent(validatedExecutionArgs: ValidatedSubscriptionArgs): PromiseOrValue<ExecutionResult>;
+/**
+ * Implements the "Subscribe" algorithm described in the GraphQL specification.
+ *
+ * Returns either an AsyncGenerator (if successful), an ExecutionResult (error),
+ * or a Promise for one of those results. The call will throw immediately if
+ * the schema is invalid or the selected operation is not a subscription.
+ *
+ * GraphQL request errors, including missing operations and variable coercion
+ * errors, return or resolve to a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data.
+ *
+ * If the source stream could not be created due to faulty subscription resolver
+ * logic, a non-async-iterable resolver result, or a system error, the
+ * function will return or resolve to a single ExecutionResult containing
+ * `errors` and no `data`.
+ *
+ * If the operation succeeded, the function returns or resolves to an
+ * AsyncGenerator, which yields a stream of ExecutionResults representing the
+ * response stream.
+ *
+ * This function does not support incremental delivery (`@defer` and `@stream`).
+ * If an operation which would defer or stream data is executed with this
+ * function, a field error will be raised at the location of the `@defer` or
+ * `@stream` directive.
+ *
+ * Accepts an object with named arguments.
+ * @param args - Execution arguments for the subscription operation.
+ * @returns A response stream for a valid subscription, or an execution result containing errors.
+ * @example
+ * ```ts
+ * // Use a same-named rootValue function to provide the source event stream.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { subscribe } from 'graphql/execution';
+ *
+ * async function* greetings() {
+ *   yield { greeting: 'Hello' };
+ *   yield { greeting: 'Bonjour' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const result = await subscribe({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ *   rootValue: { greeting: () => greetings() },
+ * });
+ *
+ * assert('next' in result);
+ *
+ * const firstPayload = await result.next();
+ * firstPayload.value; // => { data: { greeting: 'Hello' } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant supplies events through a custom subscribeFieldResolver.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { subscribe } from 'graphql/execution';
+ *
+ * async function* defaultGreetings() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * async function* frenchGreetings() {
+ *   yield { greeting: 'Bonjour' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting(locale: String): String
+ *   }
+ * `);
+ *
+ * const result = await subscribe({
+ *   schema,
+ *   document: parse(
+ *     'subscription Greeting($locale: String) { greeting(locale: $locale) }',
+ *   ),
+ *   rootValue: {
+ *     greeting: (args, contextValue) => {
+ *       const locale = args.locale ?? contextValue.defaultLocale;
+ *       return locale === 'fr' ? frenchGreetings() : defaultGreetings();
+ *     },
+ *   },
+ *   contextValue: { defaultLocale: 'fr' },
+ *   variableValues: { locale: 'fr' },
+ *   operationName: 'Greeting',
+ *   subscribeFieldResolver: (rootValue, args, contextValue, info) => {
+ *     args.locale; // => 'fr'
+ *     return rootValue[info.fieldName](args, contextValue);
+ *   },
+ * });
+ *
+ * assert('next' in result);
+ *
+ * const firstPayload = await result.next();
+ * firstPayload.value; // => { data: { greeting: 'Bonjour' } }
+ * ```
+ */
+export declare function subscribe(args: ExecutionArgs): PromiseOrValue<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult>;
+/**
+ * Implements the "CreateSourceEventStream" algorithm described in the
+ * GraphQL specification, resolving the subscription source event stream for a
+ * previously validated subscription request.
+ *
+ * Returns either an AsyncIterable (if successful), an ExecutionResult (error),
+ * or a Promise for one of those results. The call will throw immediately if
+ * it is not passed validated execution arguments.
+ *
+ * If the validated arguments do not result in a compliant subscription, a
+ * GraphQL Response (ExecutionResult) with descriptive errors and no data will
+ * be returned.
+ *
+ * If the source stream could not be created due to faulty subscription
+ * resolver logic or a system error, the function will return or
+ * resolve to a single ExecutionResult containing `errors` and no `data`.
+ *
+ * If the operation succeeded, the function returns or resolves to the
+ * AsyncIterable for the event stream returned by the resolver.
+ *
+ * A Source Event Stream represents a sequence of events, each of which triggers
+ * a GraphQL execution for that event.
+ *
+ * This may be useful when hosting the stateful subscription service in a
+ * different process or machine than the stateless GraphQL execution engine,
+ * or otherwise separating these two steps. For more on this, see the
+ * "Supporting Subscriptions at Scale" information in the GraphQL specification.
+ * @param validatedExecutionArgs - Validated subscription execution arguments.
+ * @returns A source event stream, or an execution result containing errors.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   createSourceEventStream,
+ *   validateSubscriptionArgs,
+ * } from 'graphql/execution';
+ *
+ * async function* greetings() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ * const validatedArgs = validateSubscriptionArgs({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ *   rootValue: { greeting: () => greetings() },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const stream = await createSourceEventStream(validatedArgs);
+ * Symbol.asyncIterator in stream; // => true
+ * ```
+ */
+export declare function createSourceEventStream(validatedExecutionArgs: ValidatedSubscriptionArgs): PromiseOrValue<AsyncIterable<unknown> | ExecutionResult>;
+/**
+ * Validates the arguments passed to execute, subscribe, and their lower-level
+ * helpers.
+ *
+ * Throws if the schema is invalid. GraphQL request errors, including variable
+ * coercion errors, are returned as a GraphQLError array.
+ * @param args - Execution arguments to validate.
+ * @returns Validated execution arguments, or validation errors.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validateExecutionArgs } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   interface Named {
+ *     name: String!
+ *   }
+ *
+ *   type User implements Named {
+ *     name: String!
+ *   }
+ *
+ *   type Query {
+ *     viewer: Named
+ *   }
+ * `);
+ * const abortController = new AbortController();
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('query Viewer { viewer { __typename name } }'),
+ *   rootValue: { viewer: { kind: 'user', name: 'Ada' } },
+ *   contextValue: { locale: 'en' },
+ *   operationName: 'Viewer',
+ *   fieldResolver: (source, _args, contextValue, info) => {
+ *     contextValue.locale; // => 'en'
+ *     return source[info.fieldName];
+ *   },
+ *   typeResolver: (value) => {
+ *     return value.kind === 'user' ? 'User' : undefined;
+ *   },
+ *   hideSuggestions: true,
+ *   abortSignal: abortController.signal,
+ *   enableEarlyExecution: true,
+ *   hooks: {
+ *     asyncWorkFinished: () => {},
+ *   },
+ *   options: { maxCoercionErrors: 1 },
+ * });
+ *
+ * assert('operation' in validatedArgs);
+ *
+ * validatedArgs.operation.name?.value; // => 'Viewer'
+ * validatedArgs.hideSuggestions; // => true
+ * ```
+ */
+export declare function validateExecutionArgs(args: ExecutionArgs): ReadonlyArray<GraphQLError> | ValidatedExecutionArgs;
+/**
+ * Validates execution arguments for a subscription operation.
+ *
+ * Throws if the schema is invalid or the selected operation is not a
+ * subscription. GraphQL request errors, including variable coercion errors, are
+ * returned as a GraphQLError array.
+ * @param args - Execution arguments to validate.
+ * @returns Validated subscription execution arguments, or validation errors.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validateSubscriptionArgs } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ * const validatedArgs = validateSubscriptionArgs({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ * });
+ *
+ * assert('operation' in validatedArgs);
+ *
+ * validatedArgs.operation.operation; // => 'subscription'
+ * ```
+ */
+export declare function validateSubscriptionArgs(args: ExecutionArgs): ReadonlyArray<GraphQLError> | ValidatedSubscriptionArgs;
+/**
+ * If a resolveType function is not given, then a default resolve behavior is
+ * used which attempts two strategies:
+ *
+ * First, See if the provided value has a `__typename` field defined, if so, use
+ * that value as name of the resolved type.
+ *
+ * Otherwise, test each possible type for the abstract type by calling
+ * isTypeOf for the object being coerced, returning the first type that matches.
+ */
+export declare const defaultTypeResolver: GraphQLTypeResolver<unknown, unknown>;
+/**
+ * If a resolve function is not given, then a default resolve behavior is used
+ * which takes the property of the source object of the same name as the field
+ * and returns it as the result, or if it's a function, returns the result
+ * of calling that function while passing along args and context value.
+ */
+export declare const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown>;
+/**
+ * Implements the "MapSourceToResponseEvent" algorithm described in the
+ * GraphQL specification, mapping each event from a subscription source event
+ * stream to an ExecutionResult in the response stream.
+ * @param validatedExecutionArgs - Validated subscription execution arguments.
+ * @param sourceEventStream - Source event stream returned by the subscription resolver.
+ * @param rootSelectionSetExecutor - Function used to execute each source event.
+ * @returns A response stream of execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   mapSourceToResponseEvent,
+ *   validateSubscriptionArgs,
+ * } from 'graphql/execution';
+ *
+ * async function* events() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ * const validatedArgs = validateSubscriptionArgs({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const responseStream = mapSourceToResponseEvent(validatedArgs, events());
+ * const firstPayload = await responseStream.next();
+ *
+ * firstPayload.value; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function mapSourceToResponseEvent(validatedExecutionArgs: ValidatedSubscriptionArgs, sourceEventStream: AsyncIterable<unknown>, rootSelectionSetExecutor?: RootSelectionSetExecutor): AsyncGenerator<ExecutionResult, void, void>;
+/** Function used by a GraphQL harness to parse GraphQL source text. */
+export type GraphQLParseFn = (...args: Parameters<typeof parse>) => PromiseOrValue<ReturnType<typeof parse>>;
+/** Function used by a GraphQL harness to validate a parsed document. */
+export type GraphQLValidateFn = (...args: Parameters<typeof validate>) => PromiseOrValue<ReturnType<typeof validate>>;
+/** Function used by a GraphQL harness to execute a valid operation. */
+export type GraphQLExecuteFn = (...args: Parameters<typeof execute>) => ReturnType<typeof execute>;
+/** Function used by a GraphQL harness to create a subscription response stream. */
+export type GraphQLSubscribeFn = (...args: Parameters<typeof subscribe>) => ReturnType<typeof subscribe>;
+/**
+ * Overrides for the parse, validate, execute, and subscribe stages used by the
+ * high-level `graphql` and `graphqlSync` request pipeline.
+ */
+export interface GraphQLHarness {
+	/** Parses GraphQL source text into a document AST. */
+	parse: GraphQLParseFn;
+	/** Validates a document AST against a schema. */
+	validate: GraphQLValidateFn;
+	/** Executes a valid operation. */
+	execute: GraphQLExecuteFn;
+	/** Creates a response stream for a subscription operation. */
+	subscribe: GraphQLSubscribeFn;
+}
+/**
+ * Default harness backed by GraphQL.js parse, validate, execute, and subscribe
+ * implementations.
+ */
+export declare const defaultHarness: GraphQLHarness;
+/**
+ * Describes the input object accepted by `graphql` and `graphqlSync`.
+ *
+ * These arguments describe the full parse, validate, and execute lifecycle for
+ * a GraphQL request. They include parser options, validation options, execution
+ * options, and an optional harness for replacing pipeline stages.
+ *
+ * `graphql` and `graphqlSync` do not support incremental delivery (`@defer` and
+ * `@stream`); use `experimentalExecuteIncrementally` after parsing and
+ * validating when incremental delivery is required.
+ */
+export interface GraphQLArgs extends ParseOptions, ValidationOptions, Omit<ExecutionArgs, "document"> {
+	/**
+	 * Custom parse, validate, execute, and subscribe functions for this request
+	 * pipeline.
+	 */
+	harness?: GraphQLHarness | undefined;
+	/**
+	 * A GraphQL language-formatted string or source object representing the
+	 * requested operation.
+	 */
+	source: string | Source;
+	/** Validation rules to use instead of the specified rules. */
+	rules?: ReadonlyArray<ValidationRule> | undefined;
+}
+/**
+ * Parses, validates, and executes a GraphQL document against a schema.
+ *
+ * This is the primary entry point for fulfilling GraphQL operations. Use this
+ * when you want a single-call request lifecycle that returns a promise in all
+ * cases.
+ *
+ * More sophisticated GraphQL servers, such as those which persist queries, may
+ * wish to separate the validation and execution phases to a static-time tooling
+ * step and a server runtime step.
+ * @param args - Request execution arguments, including schema and source.
+ * @returns A promise that resolves to an execution result or validation errors.
+ * @example
+ * ```ts
+ * // Execute a complete asynchronous request with variables.
+ * import { graphql, buildSchema } from 'graphql';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting(name: String!): String
+ *   }
+ * `);
+ *
+ * const result = await graphql({
+ *   schema,
+ *   source: 'query SayHello($name: String!) { greeting(name: $name) }',
+ *   rootValue: {
+ *     greeting: ({ name }) => `Hello, ${name}!`,
+ *   },
+ *   variableValues: { name: 'Ada' },
+ *   operationName: 'SayHello',
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello, Ada!' } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant supplies context plus custom field and type resolvers.
+ * import { graphql, buildSchema } from 'graphql';
+ *
+ * const schema = buildSchema(`
+ *   interface Named {
+ *     name: String!
+ *   }
+ *
+ *   type User implements Named {
+ *     name: String!
+ *   }
+ *
+ *   type Query {
+ *     viewer: Named
+ *   }
+ * `);
+ *
+ * const result = await graphql({
+ *   schema,
+ *   source: '{ viewer { __typename name } }',
+ *   rootValue: { viewer: { kind: 'user', name: 'Ada' } },
+ *   contextValue: { locale: 'en' },
+ *   fieldResolver: (source, _args, context, info) => {
+ *     context.locale; // => 'en'
+ *     return source[info.fieldName];
+ *   },
+ *   typeResolver: (value) => {
+ *     return value.kind === 'user' ? 'User' : undefined;
+ *   },
+ * });
+ *
+ * result; // => { data: { viewer: { __typename: 'User', name: 'Ada' } } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant customizes the request pipeline with a harness.
+ * import { buildSchema, defaultHarness, graphql } from 'graphql';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const stages = [];
+ * const abortController = new AbortController();
+ * const harness = {
+ *   parse: (...args) => {
+ *     stages.push('parse');
+ *     return defaultHarness.parse(...args);
+ *   },
+ *   validate: (...args) => {
+ *     stages.push('validate');
+ *     return defaultHarness.validate(...args);
+ *   },
+ *   execute: (...args) => {
+ *     stages.push('execute');
+ *     return defaultHarness.execute(...args);
+ *   },
+ *   subscribe: (...args) => {
+ *     stages.push('subscribe');
+ *     return defaultHarness.subscribe(...args);
+ *   },
+ * };
+ *
+ * const result = await graphql({
+ *   schema,
+ *   source: '{ greeting }',
+ *   rootValue: { greeting: 'Hello' },
+ *   rules: [],
+ *   maxErrors: 25,
+ *   hideSuggestions: true,
+ *   noLocation: true,
+ *   abortSignal: abortController.signal,
+ *   harness,
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello' } }
+ * stages; // => ['parse', 'validate', 'execute']
+ * ```
+ * @category Request Pipeline
+ */
+export declare function graphql(args: GraphQLArgs): Promise<ExecutionResult>;
+/**
+ * Parses, validates, and executes a GraphQL document synchronously.
+ *
+ * This function guarantees that execution completes synchronously, or throws an
+ * error, assuming that all field resolvers are also synchronous. It throws when
+ * any resolver returns a promise.
+ * @param args - Request execution arguments, including schema and source.
+ * @returns Completed execution output, or request errors if parsing or
+ * validation fails.
+ * @example
+ * ```ts
+ * // Execute a complete synchronous request with variables.
+ * import { graphqlSync, buildSchema } from 'graphql';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting(name: String!): String
+ *   }
+ * `);
+ *
+ * const result = graphqlSync({
+ *   schema,
+ *   source: 'query SayHello($name: String!) { greeting(name: $name) }',
+ *   rootValue: {
+ *     greeting: ({ name }) => `Hello, ${name}!`,
+ *   },
+ *   variableValues: { name: 'Ada' },
+ *   operationName: 'SayHello',
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello, Ada!' } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses a synchronous custom field resolver and context.
+ * import { graphqlSync, buildSchema } from 'graphql';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const result = graphqlSync({
+ *   schema,
+ *   source: '{ greeting }',
+ *   fieldResolver: (_source, _args, contextValue) => {
+ *     return contextValue.defaultGreeting;
+ *   },
+ *   contextValue: { defaultGreeting: 'Hello' },
+ * });
+ *
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ * @category Request Pipeline
+ */
+export declare function graphqlSync(args: GraphQLArgs): ExecutionResult;
+/**
+ * Render a helpful description of the location in the GraphQL Source document.
+ * @param location - The AST location to print.
+ * @returns A formatted source excerpt with line and column information.
+ * @example
+ * ```ts
+ * import { parse, printLocation } from 'graphql/language';
+ *
+ * const document = parse('type Query { hello: String }');
+ * const location = document.definitions[0].loc;
+ *
+ * if (location) {
+ *   const printed = printLocation(location);
+ *
+ *   printed; // => 'GraphQL request:1:1\n1 | type Query { hello: String }\n  | ^'
+ * }
+ * ```
+ */
+export declare function printLocation(location: Location$1): string;
+/**
+ * Render a helpful description of the location in the GraphQL Source document.
+ * @param source - The source document that contains the location.
+ * @param sourceLocation - The 1-indexed line and column to print.
+ * @returns A formatted source excerpt with line and column information.
+ * @example
+ * ```ts
+ * import { Source, printSourceLocation } from 'graphql/language';
+ *
+ * const source = new Source('type Query { hello: String }');
+ * const printed = printSourceLocation(source, { line: 1, column: 14 });
+ *
+ * printed; // => 'GraphQL request:1:14\n1 | type Query { hello: String }\n  |              ^'
+ * ```
+ */
+export declare function printSourceLocation(source: Source, sourceLocation: SourceLocation): string;
+/**
+ * Converts an AST into a string, using one set of reasonable
+ * formatting rules.
+ * @param ast - The GraphQL AST node to print.
+ * @returns A stable string representation of the AST.
+ * @example
+ * ```ts
+ * import { parse, print } from 'graphql';
+ *
+ * const ast = parse('{ hero { name } }');
+ * const text = print(ast);
+ *
+ * text; // => '{\n  hero {\n    name\n  }\n}'
+ * ```
+ */
+export declare function print(ast: ASTNode): string;
+/**
+ * Returns true when the AST node is a definition node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a definition node.
+ * @example
+ * ```ts
+ * import { parse, isDefinitionNode } from 'graphql/language';
+ *
+ * const document = parse('{ hello }');
+ *
+ * isDefinitionNode(document.definitions[0]); // => true
+ * isDefinitionNode(document); // => false
+ * ```
+ */
+export declare function isDefinitionNode(node: ASTNode): node is DefinitionNode;
+/**
+ * Returns true when the AST node is an executable definition node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is an executable definition node.
+ * @example
+ * ```ts
+ * import { parse, isExecutableDefinitionNode } from 'graphql/language';
+ *
+ * const query = parse('{ hello }');
+ * const schema = parse('type Query { hello: String }');
+ *
+ * isExecutableDefinitionNode(query.definitions[0]); // => true
+ * isExecutableDefinitionNode(schema.definitions[0]); // => false
+ * ```
+ */
+export declare function isExecutableDefinitionNode(node: ASTNode): node is ExecutableDefinitionNode;
+/**
+ * A type predicate for SubscriptionOperationDefinitionNode.
+ * Useful anywhere that must distinguish subscription operations from
+ * queries and mutations, such as the subscription execution pipeline
+ * which routes events through a different code path.
+ * @param node - Operation definition node to test.
+ * @returns True when the operation definition is a subscription.
+ * @example
+ * ```ts
+ * import { parse, isSubscriptionOperationDefinitionNode } from 'graphql/language';
+ *
+ * const subscription = parse('subscription { greeting }').definitions[0];
+ * const query = parse('{ greeting }').definitions[0];
+ *
+ * isSubscriptionOperationDefinitionNode(subscription); // => true
+ * isSubscriptionOperationDefinitionNode(query); // => false
+ * ```
+ */
+export declare function isSubscriptionOperationDefinitionNode(node: OperationDefinitionNode): node is SubscriptionOperationDefinitionNode;
+/**
+ * Returns true when the AST node is a selection node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a selection node.
+ * @example
+ * ```ts
+ * import { Kind, isSelectionNode } from 'graphql/language';
+ *
+ * const field = { kind: Kind.FIELD, name: { kind: Kind.NAME, value: 'hello' } };
+ * const document = { kind: Kind.DOCUMENT, definitions: [] };
+ *
+ * isSelectionNode(field); // => true
+ * isSelectionNode(document); // => false
+ * ```
+ */
+export declare function isSelectionNode(node: ASTNode): node is SelectionNode;
+/**
+ * Returns true when the AST node is a value node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a value node.
+ * @example
+ * ```ts
+ * import { parseType, parseValue, isValueNode } from 'graphql/language';
+ *
+ * const value = parseValue('[42]');
+ * const type = parseType('[String!]');
+ *
+ * isValueNode(value); // => true
+ * isValueNode(type); // => false
+ * ```
+ */
+export declare function isValueNode(node: ASTNode): node is ValueNode;
+/**
+ * Returns true when the AST node is a constant value node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a constant value node.
+ * @example
+ * ```ts
+ * import {
+ *   parseConstValue,
+ *   parseValue,
+ *   isConstValueNode,
+ * } from 'graphql/language';
+ *
+ * const value = parseConstValue('[42]');
+ * const variable = parseValue('$id');
+ *
+ * isConstValueNode(value); // => true
+ * isConstValueNode(variable); // => false
+ * ```
+ */
+export declare function isConstValueNode(node: ASTNode): node is ConstValueNode;
+/**
+ * Returns true when the AST node is a type node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a type node.
+ * @example
+ * ```ts
+ * import { parseType, parseValue, isTypeNode } from 'graphql/language';
+ *
+ * const type = parseType('[String!]');
+ * const value = parseValue('[42]');
+ *
+ * isTypeNode(type); // => true
+ * isTypeNode(value); // => false
+ * ```
+ */
+export declare function isTypeNode(node: ASTNode): node is TypeNode;
+/**
+ * Returns true when the AST node is a type system definition node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a type system definition node.
+ * @example
+ * ```ts
+ * import { parse, isTypeSystemDefinitionNode } from 'graphql/language';
+ *
+ * const schema = parse('type Query { hello: String }');
+ * const query = parse('{ hello }');
+ *
+ * isTypeSystemDefinitionNode(schema.definitions[0]); // => true
+ * isTypeSystemDefinitionNode(query.definitions[0]); // => false
+ * ```
+ */
+export declare function isTypeSystemDefinitionNode(node: ASTNode): node is TypeSystemDefinitionNode;
+/**
+ * Returns true when the AST node is a type definition node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a type definition node.
+ * @example
+ * ```ts
+ * import { parse, isTypeDefinitionNode } from 'graphql/language';
+ *
+ * const typeDefinition = parse('type Query { hello: String }');
+ * const directiveDefinition = parse('directive @cache on FIELD');
+ *
+ * isTypeDefinitionNode(typeDefinition.definitions[0]); // => true
+ * isTypeDefinitionNode(directiveDefinition.definitions[0]); // => false
+ * ```
+ */
+export declare function isTypeDefinitionNode(node: ASTNode): node is TypeDefinitionNode;
+/**
+ * Returns true when the AST node is a type system extension node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a type system extension node.
+ * @example
+ * ```ts
+ * import { parse, isTypeSystemExtensionNode } from 'graphql/language';
+ *
+ * const extension = parse('extend type Query { hello: String }');
+ * const definition = parse('type Query { hello: String }');
+ *
+ * isTypeSystemExtensionNode(extension.definitions[0]); // => true
+ * isTypeSystemExtensionNode(definition.definitions[0]); // => false
+ * ```
+ */
+export declare function isTypeSystemExtensionNode(node: ASTNode): node is TypeSystemExtensionNode;
+/**
+ * Returns true when the AST node is a type extension node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a type extension node.
+ * @example
+ * ```ts
+ * import { parse, isTypeExtensionNode } from 'graphql/language';
+ *
+ * const extension = parse('extend type Query { hello: String }');
+ * const schemaExtension = parse('extend schema { query: Query }');
+ *
+ * isTypeExtensionNode(extension.definitions[0]); // => true
+ * isTypeExtensionNode(schemaExtension.definitions[0]); // => false
+ * ```
+ */
+export declare function isTypeExtensionNode(node: ASTNode): node is TypeExtensionNode;
+/**
+ * Returns true when the AST node is a schema coordinate node.
+ * @param node - The AST node to test.
+ * @returns True when the AST node is a schema coordinate node.
+ * @example
+ * ```ts
+ * import {
+ *   parse,
+ *   parseSchemaCoordinate,
+ *   isSchemaCoordinateNode,
+ * } from 'graphql/language';
+ *
+ * const coordinate = parseSchemaCoordinate('Query.hero');
+ * const document = parse('{ hero }');
+ *
+ * isSchemaCoordinateNode(coordinate); // => true
+ * isSchemaCoordinateNode(document); // => false
+ * ```
+ */
+export declare function isSchemaCoordinateNode(node: ASTNode): node is SchemaCoordinateNode;
+/**
+ * Results for an operation that produced legacy incremental payloads.
+ * @typeParam TInitialData - Shape of the initial result data payload.
+ * @typeParam TDeferredData - Shape of deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface LegacyExperimentalIncrementalExecutionResults<TInitialData = ObjMap<unknown>, TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Initial execution result delivered before subsequent legacy incremental payloads. */
+	initialResult: LegacyInitialIncrementalExecutionResult<TInitialData, TExtensions>;
+	/** Async stream of legacy incremental payloads delivered after the initial result. */
+	subsequentResults: AsyncGenerator<LegacySubsequentIncrementalExecutionResult<TDeferredData, TStreamItem, TExtensions>, void, void>;
+}
+/**
+ * Initial execution result for an operation that produced legacy incremental payloads.
+ *
+ * Unlike `InitialIncrementalExecutionResult`, the legacy initial result does
+ * not include a `pending` list. Subsequent payloads identify their location
+ * directly with `path` and optional `label` fields.
+ * @typeParam TInitialData - Shape of the initial data payload.
+ * @typeParam TExtensions - Shape of the extensions payload.
+ */
+export interface LegacyInitialIncrementalExecutionResult<TInitialData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends ExecutionResult<TInitialData, TExtensions> {
+	/** Data produced by the initial execution payload. */
+	data: TInitialData;
+	/** Indicates that subsequent legacy incremental payloads will follow. */
+	hasNext: true;
+	/** Additional non-standard metadata included in the initial result. */
+	extensions?: TExtensions;
+}
+/**
+ * Subsequent payload produced by legacy incremental execution.
+ *
+ * Legacy subsequent payloads may contain deferred fragment data, streamed list
+ * items, or only `hasNext: false` to complete the response stream.
+ * @typeParam TDeferredData - Shape of deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of the extensions payload.
+ */
+export interface LegacySubsequentIncrementalExecutionResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Deferred or streamed payloads delivered by this response. */
+	incremental?: ReadonlyArray<LegacyIncrementalResult<TDeferredData, TStreamItem, TExtensions>>;
+	/** Indicates whether more legacy incremental payloads will follow. */
+	hasNext: boolean;
+	/** Additional non-standard metadata included in this payload. */
+	extensions?: TExtensions;
+}
+/**
+ * Deferred fragment or streamed list payload produced by legacy incremental execution.
+ * @typeParam TDeferredData - Shape of deferred fragment data.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export type LegacyIncrementalResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> = LegacyIncrementalDeferResult<TDeferredData, TExtensions> | LegacyIncrementalStreamResult<TStreamItem, TExtensions>;
+/**
+ * Legacy incremental payload produced by a deferred fragment.
+ *
+ * The payload location is identified directly by `path` and optional `label`
+ * instead of by an `id` from a pending entry.
+ * @typeParam TDeferredData - Shape of deferred fragment data.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface LegacyIncrementalDeferResult<TDeferredData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends ExecutionResult<TDeferredData, TExtensions> {
+	/** Response path to the deferred fragment payload. */
+	path: ReadonlyArray<string | number>;
+	/** Label from the `@defer` directive. */
+	label?: string;
+}
+/**
+ * Legacy incremental payload produced by a streamed list field.
+ * @typeParam TStreamItem - Shape of streamed list items.
+ * @typeParam TExtensions - Shape of extensions payloads.
+ */
+export interface LegacyIncrementalStreamResult<TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Errors raised while producing streamed items. */
+	errors?: ReadonlyArray<GraphQLError>;
+	/** Streamed list items delivered by this payload. */
+	items: ReadonlyArray<TStreamItem> | null;
+	/** Response path to the first streamed list item in this payload. */
+	path: ReadonlyArray<string | number>;
+	/** Label from the `@stream` directive. */
+	label?: string;
+	/** Additional non-standard metadata included in this payload. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of legacy incremental execution results.
+ * @typeParam TInitialData - Shape of the formatted initial result data payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedLegacyExperimentalIncrementalExecutionResults<TInitialData = ObjMap<unknown>, TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Formatted initial execution result. */
+	initialResult: FormattedLegacyInitialIncrementalExecutionResult<TInitialData, TExtensions>;
+	/** Async stream of formatted legacy incremental payloads. */
+	subsequentResults: AsyncGenerator<FormattedLegacySubsequentIncrementalExecutionResult<TDeferredData, TStreamItem, TExtensions>, void, void>;
+}
+/**
+ * JSON-serializable form of a legacy initial incremental execution result.
+ * @typeParam TInitialData - Shape of the formatted initial data payload.
+ * @typeParam TExtensions - Shape of the formatted extensions payload.
+ */
+export interface FormattedLegacyInitialIncrementalExecutionResult<TInitialData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TInitialData, TExtensions> {
+	/** Formatted data produced by the initial execution payload. */
+	data: TInitialData;
+	/** Indicates that subsequent legacy incremental payloads will follow. */
+	hasNext: true;
+	/** Additional non-standard metadata included in the formatted initial result. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable form of a legacy subsequent incremental execution payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data payloads.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedLegacySubsequentIncrementalExecutionResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Formatted deferred or streamed payloads delivered by this response. */
+	incremental?: ReadonlyArray<FormattedLegacyIncrementalResult<TDeferredData, TStreamItem, TExtensions>>;
+	/** Indicates whether more legacy incremental payloads will follow. */
+	hasNext: boolean;
+	/** Additional non-standard metadata included in this formatted payload. */
+	extensions?: TExtensions;
+}
+/**
+ * JSON-serializable deferred fragment or streamed list payload produced by
+ * legacy incremental execution.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export type FormattedLegacyIncrementalResult<TDeferredData = ObjMap<unknown>, TStreamItem = unknown, TExtensions = ObjMap<unknown>> = FormattedLegacyIncrementalDeferResult<TDeferredData, TExtensions> | FormattedLegacyIncrementalStreamResult<TStreamItem, TExtensions>;
+/**
+ * JSON-serializable form of a legacy deferred fragment payload.
+ * @typeParam TDeferredData - Shape of formatted deferred fragment data.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedLegacyIncrementalDeferResult<TDeferredData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TDeferredData, TExtensions> {
+	/** Response path to the formatted deferred fragment payload. */
+	path: ReadonlyArray<string | number>;
+	/** Label from the `@defer` directive. */
+	label?: string;
+}
+/**
+ * JSON-serializable form of a legacy streamed list payload.
+ * @typeParam TStreamItem - Shape of formatted streamed list items.
+ * @typeParam TExtensions - Shape of formatted extensions payloads.
+ */
+export interface FormattedLegacyIncrementalStreamResult<TStreamItem = unknown, TExtensions = ObjMap<unknown>> {
+	/** Formatted errors raised while producing streamed items. */
+	errors?: ReadonlyArray<GraphQLFormattedError>;
+	/** Formatted streamed list items delivered by this payload. */
+	items: ReadonlyArray<TStreamItem> | null;
+	/** Response path to the first streamed list item in this formatted payload. */
+	path: ReadonlyArray<string | number>;
+	/** Label from the `@stream` directive. */
+	label?: string;
+	/** Additional non-standard metadata included in this formatted payload. */
+	extensions?: TExtensions;
+}
+/**
+ * Executes a GraphQL operation with support for `@defer` and `@stream` using
+ * the legacy incremental delivery payload format.
+ *
+ * Prefer `experimentalExecuteIncrementally` for the current incremental
+ * delivery format. In the legacy format, each subsequent incremental payload
+ * identifies its location with `path` and optional `label` fields. The current
+ * format instead tracks pending work by `id` and reports completion through
+ * `completed` entries.
+ * @param args - Execution arguments for the GraphQL operation.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { legacyExecuteIncrementally } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ *
+ * const result = await legacyExecuteIncrementally({
+ *   schema,
+ *   document: parse('{ hero { id ... @defer(label: "HeroName") { name } } }'),
+ *   rootValue: { hero: { id: '1', name: 'Luke' } },
+ * });
+ *
+ * assert('initialResult' in result);
+ *
+ * result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const deferred = await result.subsequentResults.next();
+ * deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }
+ * ```
+ * @example
+ * Compare the legacy payload format with the current incremental delivery
+ * format returned by `experimentalExecuteIncrementally`.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ * const document = parse('{ hero { id ... @defer { name } } }');
+ * const rootValue = { hero: { id: '1', name: 'Luke' } };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const experimentalDeferred = await experimental.subsequentResults.next();
+ * experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyDeferred = await legacy.subsequentResults.next();
+ * legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }
+ * ```
+ * @example
+ * Compare streamed list payloads in the legacy and current incremental
+ * delivery formats.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { colors: [String] }');
+ * const document = parse('{ colors @stream(initialCount: 1) }');
+ * const rootValue = { colors: ['red', 'green', 'blue'] };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }
+ *
+ * const experimentalStream = await experimental.subsequentResults.next();
+ * experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyStream = await legacy.subsequentResults.next();
+ * legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }
+ * ```
+ */
+export declare function legacyExecuteIncrementally(args: ExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;
+/**
+ * Executes a validated operation root selection set with support for `@defer`
+ * and `@stream` using the legacy incremental delivery payload format.
+ * @param validatedExecutionArgs - Validated execution arguments.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   legacyExecuteRootSelectionSet,
+ *   validateExecutionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await legacyExecuteRootSelectionSet(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function legacyExecuteRootSelectionSet(validatedExecutionArgs: ValidatedExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+export declare const recommendedRules: ReadonlyArray<ValidationRule>;
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+export declare const specifiedRules: ReadonlyArray<ValidationRule>;
+/**
+ * Defer and stream directive labels are unique
+ *
+ * A GraphQL document is only valid if defer and stream directives' label argument is static and unique.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validate, DeferStreamDirectiveLabelRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     friends: [String]
+ *   }
+ * `);
+ * const invalidDocument = parse(`
+ *   {
+ *     friends @stream(label: "friends")
+ *     other: friends @stream(label: "friends")
+ *   }
+ * `);
+ * const validDocument = parse(`
+ *   {
+ *     friends @stream(label: "friends")
+ *     other: friends @stream(label: "otherFriends")
+ *   }
+ * `);
+ *
+ * validate(schema, invalidDocument, [DeferStreamDirectiveLabelRule]).length; // => 1
+ * validate(schema, validDocument, [DeferStreamDirectiveLabelRule]); // => []
+ * ```
+ */
+export declare function DeferStreamDirectiveLabelRule(context: ValidationContext): ASTVisitor;
+/**
+ * Defer and stream directives are used on valid root field
+ *
+ * A GraphQL document is only valid if defer directives are not used on root mutation or subscription types.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   validate,
+ *   DeferStreamDirectiveOnRootFieldRule,
+ * } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     message: String
+ *   }
+ *
+ *   type Mutation {
+ *     updateMessage: String
+ *   }
+ * `);
+ * const invalidDocument = parse(`
+ *   mutation { ... @defer { updateMessage } }
+ * `);
+ * const validDocument = parse(`
+ *   { ... @defer { message } }
+ * `);
+ *
+ * validate(schema, invalidDocument, [DeferStreamDirectiveOnRootFieldRule]).length; // => 1
+ * validate(schema, validDocument, [DeferStreamDirectiveOnRootFieldRule]); // => []
+ * ```
+ */
+export declare function DeferStreamDirectiveOnRootFieldRule(context: ValidationContext): ASTVisitor;
+/**
+ * Defer And Stream Directives Are Used On Valid Operations
+ *
+ * A GraphQL document is only valid if defer and stream directives are not used on root mutation or subscription types.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   validate,
+ *   DeferStreamDirectiveOnValidOperationsRule,
+ * } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     message: Message
+ *   }
+ *
+ *   type Subscription {
+ *     message: Message
+ *   }
+ *
+ *   type Message {
+ *     body: String
+ *   }
+ * `);
+ * const invalidDocument = parse(`
+ *   subscription {
+ *     message {
+ *       ...MessageBody @defer
+ *     }
+ *   }
+ *
+ *   fragment MessageBody on Message {
+ *     body
+ *   }
+ * `);
+ * const validDocument = parse(`
+ *   subscription {
+ *     message {
+ *       ...MessageBody @defer(if: false)
+ *     }
+ *   }
+ *
+ *   fragment MessageBody on Message {
+ *     body
+ *   }
+ * `);
+ *
+ * validate(schema, invalidDocument, [DeferStreamDirectiveOnValidOperationsRule])
+ *   .length; // => 1
+ * validate(schema, validDocument, [DeferStreamDirectiveOnValidOperationsRule]); // => []
+ * ```
+ */
+export declare function DeferStreamDirectiveOnValidOperationsRule(context: ValidationContext): ASTVisitor;
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ExecutableDefinitionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   type Extra { field: String }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   ExecutableDefinitionsRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   ExecutableDefinitionsRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function ExecutableDefinitionsRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Fields on correct type
+ *
+ * A GraphQL document is only valid if all fields selected are defined by the
+ * parent type, or are an allowed meta field such as __typename.
+ *
+ * See https://spec.graphql.org/draft/#sec-Field-Selections
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { FieldsOnCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { missing }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   FieldsOnCorrectTypeRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [FieldsOnCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function FieldsOnCorrectTypeRule(context: ValidationContext): ASTVisitor;
+/**
+ * Fragments on composite type
+ *
+ * Fragments use a type condition to determine if they apply, since fragments
+ * can only be spread into a composite type (object, interface, or union), the
+ * type condition must also be a composite type.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragments-On-Composite-Types
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { FragmentsOnCompositeTypesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Bad on String { length }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   FragmentsOnCompositeTypesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Good on Query { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   FragmentsOnCompositeTypesRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function FragmentsOnCompositeTypesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Known argument names
+ *
+ * A GraphQL field is only valid if all supplied arguments are defined by
+ * that field.
+ *
+ * See https://spec.graphql.org/draft/#sec-Argument-Names
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-In-Valid-Locations
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownArgumentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: String): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field(unknown: "1") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   KnownArgumentNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(arg: "1") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownArgumentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Known directives
+ *
+ * A GraphQL document is only valid if all `@directives` are known by the
+ * schema and legally positioned.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownDirectivesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @unknown }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [KnownDirectivesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownDirectivesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function KnownDirectivesRule(context: ValidationContext | SDLValidationContext): ASTVisitor;
+/**
+ * Known fragment names
+ *
+ * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+ * to fragments defined in the same document.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownFragmentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { ...Missing }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   KnownFragmentNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment NameFields on Query { name } query { ...NameFields }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownFragmentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function KnownFragmentNamesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Known Operation Types
+ *
+ * A GraphQL document is only valid if when it contains an operation,
+ * the root type for the operation exists within the schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Operation-Type-Existence
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validate, KnownOperationTypesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const invalidDocument = parse('mutation { greeting }');
+ * const validDocument = parse('{ greeting }');
+ *
+ * validate(schema, invalidDocument, [KnownOperationTypesRule])[0].message; // => 'The mutation operation is not supported by the schema.'
+ * validate(schema, validDocument, [KnownOperationTypesRule]); // => []
+ * ```
+ */
+export declare function KnownOperationTypesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Known type names
+ *
+ * A GraphQL document is only valid if referenced types (specifically
+ * variable definitions and fragment conditions) are defined by the type schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownTypeNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Bad on Missing { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [KnownTypeNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Good on Query { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownTypeNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function KnownTypeNamesRule(context: ValidationContext | SDLValidationContext): ASTVisitor;
+/**
+ * Lone anonymous operation
+ *
+ * A GraphQL document is only valid if when it contains an anonymous operation
+ * (the query short-hand) that it contains only that one operation definition.
+ *
+ * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { LoneAnonymousOperationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query { name } query Other { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   LoneAnonymousOperationRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   LoneAnonymousOperationRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function LoneAnonymousOperationRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * No fragment cycles
+ *
+ * The 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.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoFragmentCyclesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { ...B } fragment B on Query { ...A } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoFragmentCyclesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoFragmentCyclesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoFragmentCyclesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * No undefined variables
+ *
+ * A GraphQL operation is only valid if all variables encountered, both directly
+ * and via fragment spreads, are defined by that operation.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUndefinedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { field(arg: $missing) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   NoUndefinedVariablesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUndefinedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoUndefinedVariablesRule(context: ValidationContext): ASTVisitor;
+/**
+ * No unused fragments
+ *
+ * A GraphQL document is only valid if all fragment definitions are spread
+ * within operations, or spread within other fragments spread within operations.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUnusedFragmentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Unused on Query { name } query { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   NoUnusedFragmentsRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Used on Query { name } query { ...Used }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedFragmentsRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoUnusedFragmentsRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * No unused variables
+ *
+ * A GraphQL operation is only valid if all variables defined by an operation
+ * are used, either directly or within a spread fragment.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variables-Used
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUnusedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   NoUnusedVariablesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoUnusedVariablesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Overlapping fields can be merged
+ *
+ * A selection set is only valid if all fields (including spreading any
+ * fragments) either correspond to distinct response names or can be merged
+ * without ambiguity.
+ *
+ * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { OverlappingFieldsCanBeMergedRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     name: String
+ *     barkVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { value: barkVolume value: name } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   OverlappingFieldsCanBeMergedRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { barkVolume name } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   OverlappingFieldsCanBeMergedRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function OverlappingFieldsCanBeMergedRule(context: ValidationContext): ASTVisitor;
+/**
+ * Possible fragment spread
+ *
+ * A fragment spread is only valid if the type condition could ever possibly
+ * be true: if there is a non-empty intersection of the possible parent types,
+ * and possible types which pass the type condition.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { PossibleFragmentSpreadsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     barkVolume: Int
+ *   }
+ *
+ *   type Cat {
+ *     meowVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { ... on Cat { meowVolume } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   PossibleFragmentSpreadsRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { ... on Dog { barkVolume } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   PossibleFragmentSpreadsRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function PossibleFragmentSpreadsRule(context: ValidationContext): ASTVisitor;
+/**
+ * Provided required arguments
+ *
+ * A field or directive is only valid if all required (non-null without a
+ * default value) field arguments have been provided.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ProvidedRequiredArgumentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(required: String!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   ProvidedRequiredArgumentsRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(required: "x") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   ProvidedRequiredArgumentsRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function ProvidedRequiredArgumentsRule(context: ValidationContext): ASTVisitor;
+/**
+ * Scalar leafs
+ *
+ * A GraphQL document is valid only if all leaf fields (fields without
+ * sub selections) are of scalar or enum types.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ScalarLeafsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name { length } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ScalarLeafsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ScalarLeafsRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function ScalarLeafsRule(context: ValidationContext): ASTVisitor;
+/**
+ * Subscriptions must only include a non-introspection field.
+ *
+ * A GraphQL subscription is valid only if it contains a single root field and
+ * that root field is not an introspection field.
+ *
+ * See https://spec.graphql.org/draft/#sec-Single-root-field
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { SingleFieldSubscriptionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ *
+ *   type Subscription {
+ *     a: String
+ *     b: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   subscription { a b }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   SingleFieldSubscriptionsRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   subscription { a }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   SingleFieldSubscriptionsRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function SingleFieldSubscriptionsRule(context: ValidationContext): ASTVisitor;
+/**
+ * Stream directives are used on list fields
+ *
+ * A GraphQL document is only valid if stream directives are used on list fields.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { validate, StreamDirectiveOnListFieldRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *     friends: [String]
+ *   }
+ * `);
+ * const invalidDocument = parse('{ name @stream(initialCount: 0) }');
+ * const validDocument = parse('{ friends @stream(initialCount: 0) }');
+ *
+ * validate(schema, invalidDocument, [StreamDirectiveOnListFieldRule]).length; // => 1
+ * validate(schema, validDocument, [StreamDirectiveOnListFieldRule]); // => []
+ * ```
+ */
+export declare function StreamDirectiveOnListFieldRule(context: ValidationContext): ASTVisitor;
+/**
+ * Unique argument names
+ *
+ * A GraphQL field or directive is only valid if all supplied arguments are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Argument-Names
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueArgumentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: String): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field(arg: "1", arg: "2") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueArgumentNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(arg: "1") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueArgumentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueArgumentNamesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueDirectivesPerLocationRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   UniqueDirectivesPerLocationRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueDirectivesPerLocationRule(context: ValidationContext | SDLValidationContext): ASTVisitor;
+/**
+ * Unique fragment names
+ *
+ * A GraphQL document is only valid if all defined fragments have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueFragmentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { name } fragment A on Query { name } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueFragmentNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueFragmentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueFragmentNamesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Unique input field names
+ *
+ * A GraphQL input object value is only valid if all supplied fields are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueInputFieldNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   input Filter {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     search(filter: Filter): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { search(filter: { name: "a", name: "b" }) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueInputFieldNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { search(filter: { name: "a" }) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   UniqueInputFieldNamesRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueInputFieldNamesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Unique operation names
+ *
+ * A GraphQL document is only valid if all defined operations have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueOperationNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query Same { name } query Same { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueOperationNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query One { name } query Two { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueOperationNamesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Unique variable names
+ *
+ * A GraphQL operation is only valid if all its variables are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueVariableNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID, $id: ID) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   UniqueVariableNamesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueVariableNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueVariableNamesRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Value literals of correct type
+ *
+ * A GraphQL document is only valid if all value literals are of the type
+ * expected at their position.
+ *
+ * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ValuesOfCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     count(limit: Int): Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { count(limit: "many") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   ValuesOfCorrectTypeRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { count(limit: 1) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function ValuesOfCorrectTypeRule(context: ValidationContext): ASTVisitor;
+/**
+ * Variables are input types
+ *
+ * A GraphQL operation is only valid if all the variables it defines are of
+ * input types (scalar, enum, or input object).
+ *
+ * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { VariablesAreInputTypesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ *
+ *   type User {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($user: User) { field(arg: "1") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   VariablesAreInputTypesRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   VariablesAreInputTypesRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function VariablesAreInputTypesRule(context: ValidationContext): ASTVisitor;
+/**
+ * Variables in allowed position
+ *
+ * Variable usages must be compatible with the arguments they are passed to.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { VariablesInAllowedPositionRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: String) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   VariablesInAllowedPositionRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID!) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   VariablesInAllowedPositionRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function VariablesInAllowedPositionRule(context: ValidationContext): ASTVisitor;
+/**
+ * Implements the max introspection depth validation rule.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { MaxIntrospectionDepthRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { types { fields { type { fields { type { fields { name } } } } } } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   MaxIntrospectionDepthRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   MaxIntrospectionDepthRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function MaxIntrospectionDepthRule(context: ASTValidationContext): ASTVisitor;
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { LoneSchemaDefinitionRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query } schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * LoneSchemaDefinitionRule.name; // => 'LoneSchemaDefinitionRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function LoneSchemaDefinitionRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueOperationTypesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueOperationTypesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueTypeNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String } type Query { other: String }
+ * `;
+ *
+ * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueTypeNamesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueEnumValueNamesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique field definition names
+ *
+ * A GraphQL complex type is only valid if all its fields are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueFieldDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String name: String }
+ * `;
+ *
+ * UniqueFieldDefinitionNamesRule.name; // => 'UniqueFieldDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueFieldDefinitionNamesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique argument definition names
+ *
+ * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.
+ * A GraphQL Directive is only valid if all its arguments are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueArgumentDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { field(arg: String, arg: Int): String }
+ * `;
+ *
+ * UniqueArgumentDefinitionNamesRule.name; // => 'UniqueArgumentDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { field(arg: String): String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueArgumentDefinitionNamesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueDirectiveNamesRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * Possible type extension
+ *
+ * A type extension is only valid if the type is defined and has the same kind.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { PossibleTypeExtensionsRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   extend type Missing { name: String } type Query { name: String }
+ * `;
+ *
+ * PossibleTypeExtensionsRule.name; // => 'PossibleTypeExtensionsRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } extend type Query { other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function PossibleTypeExtensionsRule(context: SDLValidationContext): ASTVisitor;
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLObjectType,
+ *   GraphQLSchema,
+ *   GraphQLString,
+ *   parse,
+ *   validate,
+ * } from 'graphql';
+ * import { NoDeprecatedCustomRule } from 'graphql/validation';
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       name: { type: GraphQLString },
+ *       oldName: {
+ *         type: GraphQLString,
+ *         deprecationReason: 'Use name instead.',
+ *       },
+ *     },
+ *   }),
+ * });
+ *
+ * const invalidDocument = parse(`
+ *   { oldName }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   NoDeprecatedCustomRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoDeprecatedCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoDeprecatedCustomRule(context: ValidationContext): ASTVisitor;
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoSchemaIntrospectionCustomRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [
+ *   NoSchemaIntrospectionCustomRule,
+ * ]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [
+ *   NoSchemaIntrospectionCustomRule,
+ * ]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoSchemaIntrospectionCustomRule(context: ValidationContext): ASTVisitor;
+/**
+ * Produces a GraphQLError representing a syntax error, containing useful
+ * descriptive information about the syntax error's position in the source.
+ * @param source - The GraphQL source containing the syntax error.
+ * @param position - Character offset where the syntax error was encountered.
+ * @param description - Human-readable description of the syntax error.
+ * @returns A GraphQLError located at the syntax error position.
+ * @example
+ * ```ts
+ * import { Source } from 'graphql/language';
+ * import { syntaxError } from 'graphql/error';
+ *
+ * const error = syntaxError(new Source('query {'), 7, 'Expected Name');
+ *
+ * error.message; // => 'Syntax Error: Expected Name'
+ * error.locations; // => [{ line: 1, column: 8 }]
+ * ```
+ */
+export declare function syntaxError(source: Source, position: number, description: string): GraphQLError;
+/**
+ * Given an arbitrary value, presumably thrown while attempting to execute a
+ * GraphQL operation, produce a new GraphQLError aware of the location in the
+ * document responsible for the original Error.
+ * @param rawOriginalError - The original error value to wrap.
+ * @param nodes - The AST nodes associated with the error.
+ * @param path - The response path associated with the error.
+ * @returns The GraphQL error.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { locatedError } from 'graphql/error';
+ *
+ * const document = parse('{ viewer { name } }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ * const error = locatedError(new Error('Resolver failed'), fieldNode, ['viewer']);
+ *
+ * error.message; // => 'Resolver failed'
+ * error.locations; // => [{ line: 1, column: 3 }]
+ * error.path; // => ['viewer']
+ * ```
+ */
+export declare function locatedError(rawOriginalError: unknown, nodes: ASTNode | ReadonlyArray<ASTNode> | undefined | null, path?: Maybe<ReadonlyArray<string | number>>): GraphQLError;
+/** Options controlling which fields are included in the introspection query. */
+export interface IntrospectionOptions {
+	/**
+	 * Whether to include descriptions in the introspection result.
+	 * Default: true
+	 */
+	descriptions?: boolean;
+	/**
+	 * Whether to include `specifiedByURL` in the introspection result.
+	 * Default: false
+	 */
+	specifiedByUrl?: boolean;
+	/**
+	 * Whether to include `isRepeatable` flag on directives.
+	 * Default: false
+	 */
+	directiveIsRepeatable?: boolean;
+	/**
+	 * Whether to include `description` field on schema.
+	 * Default: false
+	 */
+	schemaDescription?: boolean;
+	/**
+	 * Whether target GraphQL server support deprecation of input values.
+	 * Default: false
+	 */
+	inputValueDeprecation?: boolean;
+	/**
+	 * Whether target GraphQL server supports deprecation of directives.
+	 * Default: false
+	 */
+	experimentalDirectiveDeprecation?: boolean;
+	/**
+	 * Whether target GraphQL server supports `@oneOf` input objects.
+	 * Default: false
+	 */
+	oneOf?: boolean;
+	/**
+	 * How deep to recurse into nested types, larger values will result in more
+	 * accurate results, but have a higher load on the server.
+	 * Some servers might restrict the maximum query depth or complexity.
+	 * If that's the case, try decreasing this value.
+	 *
+	 * Default: 9
+	 */
+	typeDepth?: number;
+}
+/**
+ * Produce the GraphQL query recommended for a full schema introspection.
+ * Accepts optional IntrospectionOptions.
+ * @param options - Optional configuration for this operation.
+ * @returns The resolved introspection query.
+ * @example
+ * ```ts
+ * // Generate the default introspection query.
+ * import { getIntrospectionQuery } from 'graphql/utilities';
+ *
+ * const query = getIntrospectionQuery();
+ *
+ * query; // matches /__schema/
+ * query; // matches /description/
+ * query; // does not match /specifiedByURL/
+ * ```
+ * @example
+ * ```ts
+ * // This variant customizes optional introspection fields and nesting depth.
+ * import { getIntrospectionQuery } from 'graphql/utilities';
+ *
+ * const query = getIntrospectionQuery({
+ *   descriptions: false,
+ *   specifiedByUrl: true,
+ *   directiveIsRepeatable: true,
+ *   schemaDescription: true,
+ *   inputValueDeprecation: true,
+ *   experimentalDirectiveDeprecation: true,
+ *   oneOf: true,
+ *   typeDepth: 3,
+ * });
+ *
+ * query; // does not match /description/
+ * query; // matches /specifiedByURL/
+ * query; // matches /isRepeatable/
+ * query; // matches /includeDeprecated: true/
+ * query; // matches /isOneOf/
+ * (query.match(/ofType/g)?.length ?? 0) > 0; // => true
+ * ```
+ */
+export declare function getIntrospectionQuery(options?: IntrospectionOptions): string;
+/** The result shape returned by a full introspection query. */
+export interface IntrospectionQuery {
+	/** The  schema. */
+	readonly __schema: IntrospectionSchema;
+}
+/** The introspection representation of a GraphQL schema. */
+export interface IntrospectionSchema {
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** The root object type used for query operations. */
+	readonly queryType: IntrospectionNamedTypeRef<IntrospectionObjectType>;
+	/** The root object type used for mutation operations, if supported. */
+	readonly mutationType: Maybe<IntrospectionNamedTypeRef<IntrospectionObjectType>>;
+	/** The root object type used for subscription operations, if supported. */
+	readonly subscriptionType: Maybe<IntrospectionNamedTypeRef<IntrospectionObjectType>>;
+	/** Object types that belong to this union type. */
+	readonly types: ReadonlyArray<IntrospectionType>;
+	/** Directives available in this schema or applied to this AST node. */
+	readonly directives: ReadonlyArray<IntrospectionDirective>;
+}
+/** Any introspection representation of a GraphQL type. */
+export type IntrospectionType = IntrospectionScalarType | IntrospectionObjectType | IntrospectionInterfaceType | IntrospectionUnionType | IntrospectionEnumType | IntrospectionInputObjectType;
+/** An introspection type that can appear in output position. */
+export type IntrospectionOutputType = IntrospectionScalarType | IntrospectionObjectType | IntrospectionInterfaceType | IntrospectionUnionType | IntrospectionEnumType;
+/** An introspection type that can appear in input position. */
+export type IntrospectionInputType = IntrospectionScalarType | IntrospectionEnumType | IntrospectionInputObjectType;
+/** The introspection representation of a scalar type. */
+export interface IntrospectionScalarType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.SCALAR;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** URL identifying the behavior specified for this custom scalar. */
+	readonly specifiedByURL?: Maybe<string>;
+}
+/** The introspection representation of an object type. */
+export interface IntrospectionObjectType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.OBJECT;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields: ReadonlyArray<IntrospectionField>;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces: ReadonlyArray<IntrospectionNamedTypeRef<IntrospectionInterfaceType>>;
+}
+/** The introspection representation of an interface type. */
+export interface IntrospectionInterfaceType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.INTERFACE;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Fields declared by this object, interface, input object, or literal. */
+	readonly fields: ReadonlyArray<IntrospectionField>;
+	/** Interfaces implemented by this object or interface type. */
+	readonly interfaces: ReadonlyArray<IntrospectionNamedTypeRef<IntrospectionInterfaceType>>;
+	/** Object types that may be returned for this abstract type. */
+	readonly possibleTypes: ReadonlyArray<IntrospectionNamedTypeRef<IntrospectionObjectType>>;
+}
+/** The introspection representation of a union type. */
+export interface IntrospectionUnionType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.UNION;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Object types that may be returned for this abstract type. */
+	readonly possibleTypes: ReadonlyArray<IntrospectionNamedTypeRef<IntrospectionObjectType>>;
+}
+/** The introspection representation of an enum type. */
+export interface IntrospectionEnumType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.ENUM;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Values declared by this enum type. */
+	readonly enumValues: ReadonlyArray<IntrospectionEnumValue>;
+}
+/** The introspection representation of an input object type. */
+export interface IntrospectionInputObjectType {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.INPUT_OBJECT;
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Input fields declared by this input object type. */
+	readonly inputFields: ReadonlyArray<IntrospectionInputValue>;
+	/** Whether this input object uses the experimental OneOf input object semantics. */
+	readonly isOneOf: boolean;
+}
+/**
+ * The introspection representation of a list type reference.
+ * @typeParam T - The introspection type reference wrapped by this list type reference.
+ */
+export interface IntrospectionListTypeRef<T extends IntrospectionTypeRef = IntrospectionTypeRef> {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.LIST;
+	/** The type wrapped by this list or non-null type. */
+	readonly ofType: T;
+}
+/**
+ * The introspection representation of a non-null type reference.
+ * @typeParam T - The introspection type reference wrapped by this non-null type reference.
+ */
+export interface IntrospectionNonNullTypeRef<T extends IntrospectionTypeRef = IntrospectionTypeRef> {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: typeof TypeKind.NON_NULL;
+	/** The type wrapped by this list or non-null type. */
+	readonly ofType: T;
+}
+/** Any introspection representation of a type reference. */
+export type IntrospectionTypeRef = IntrospectionNamedTypeRef | IntrospectionListTypeRef | IntrospectionNonNullTypeRef<IntrospectionNamedTypeRef | IntrospectionListTypeRef>;
+/** An introspection type reference that can appear in output position. */
+export type IntrospectionOutputTypeRef = IntrospectionNamedTypeRef<IntrospectionOutputType> | IntrospectionListTypeRef<IntrospectionOutputTypeRef> | IntrospectionNonNullTypeRef<IntrospectionNamedTypeRef<IntrospectionOutputType> | IntrospectionListTypeRef<IntrospectionOutputTypeRef>>;
+/** An introspection type reference that can appear in input position. */
+export type IntrospectionInputTypeRef = IntrospectionNamedTypeRef<IntrospectionInputType> | IntrospectionListTypeRef<IntrospectionInputTypeRef> | IntrospectionNonNullTypeRef<IntrospectionNamedTypeRef<IntrospectionInputType> | IntrospectionListTypeRef<IntrospectionInputTypeRef>>;
+/**
+ * The introspection representation of a named type reference.
+ * @typeParam T - The introspection type represented by this named type reference.
+ */
+export interface IntrospectionNamedTypeRef<T extends IntrospectionType = IntrospectionType> {
+	/** The introspection kind discriminator for this type reference or type. */
+	readonly kind: T["kind"];
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+}
+/** The introspection representation of a field. */
+export interface IntrospectionField {
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Arguments accepted by this field or directive. */
+	readonly args: ReadonlyArray<IntrospectionInputValue>;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: IntrospectionOutputTypeRef;
+	/** Whether this field, argument, enum value, or input value is deprecated. */
+	readonly isDeprecated: boolean;
+	/** Reason this element is deprecated, if one was provided. */
+	readonly deprecationReason: Maybe<string>;
+}
+/** The introspection representation of an argument or input field. */
+export interface IntrospectionInputValue {
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** The GraphQL type reference or runtime type for this element. */
+	readonly type: IntrospectionInputTypeRef;
+	/** Default value used when no explicit value is supplied. */
+	readonly defaultValue: Maybe<string>;
+	/** Whether this field, argument, enum value, or input value is deprecated. */
+	readonly isDeprecated?: boolean;
+	/** Reason this element is deprecated, if one was provided. */
+	readonly deprecationReason?: Maybe<string>;
+}
+/** The introspection representation of an enum value. */
+export interface IntrospectionEnumValue {
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Whether this field, argument, enum value, or input value is deprecated. */
+	readonly isDeprecated: boolean;
+	/** Reason this element is deprecated, if one was provided. */
+	readonly deprecationReason: Maybe<string>;
+}
+/** The introspection representation of a directive. */
+export interface IntrospectionDirective {
+	/** The GraphQL name for this schema element. */
+	readonly name: string;
+	/** Human-readable description for this schema element, if provided. */
+	readonly description?: Maybe<string>;
+	/** Whether this directive may appear more than once at the same location. */
+	readonly isRepeatable?: boolean;
+	/** Whether this field, argument, enum value, or input value is deprecated. */
+	readonly isDeprecated?: boolean;
+	/** Reason this element is deprecated, if one was provided. */
+	readonly deprecationReason?: Maybe<string>;
+	/** Locations where this directive may be applied. */
+	readonly locations: ReadonlyArray<DirectiveLocation>;
+	/** Arguments accepted by this field or directive. */
+	readonly args: ReadonlyArray<IntrospectionInputValue>;
+}
+/**
+ * Returns an operation AST given a document AST and optionally an operation
+ * name. If a name is not provided, an operation is only returned if only one is
+ * provided in the document.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param operationName - The optional operation name to select.
+ * @returns The resolved operation ast.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { getOperationAST } from 'graphql/utilities';
+ *
+ * const document = parse('query GetName { name }');
+ * const operation = getOperationAST(document, 'GetName');
+ *
+ * operation.name.value; // => 'GetName'
+ * getOperationAST(document, 'Missing'); // => undefined
+ * ```
+ */
+export declare function getOperationAST(documentAST: DocumentNode, operationName?: Maybe<string>): Maybe<OperationDefinitionNode>;
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ * @param schema - GraphQL schema to use.
+ * @param options - Optional configuration for this operation.
+ * @returns Introspection result data for the schema.
+ * @example
+ * ```ts
+ * // Include schema metadata using the default introspection options.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema);
+ * const urlType = introspection.__schema.types.find(
+ *   (type) => type.name === 'Url',
+ * );
+ *
+ * urlType.specifiedByURL; // => 'https://url.spec.whatwg.org/'
+ * ```
+ * @example
+ * ```ts
+ * // This variant disables optional introspection metadata.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema, {
+ *   descriptions: false,
+ *   specifiedByUrl: false,
+ *   directiveIsRepeatable: false,
+ *   schemaDescription: false,
+ *   inputValueDeprecation: false,
+ *   experimentalDirectiveDeprecation: false,
+ *   oneOf: false,
+ * });
+ * const urlType = introspection.__schema.types.find(
+ *   (type) => type.name === 'Url',
+ * );
+ * const deprecatedDirective = introspection.__schema.directives.find(
+ *   (directive) => directive.name === 'deprecated',
+ * );
+ *
+ * urlType.specifiedByURL; // => undefined
+ * urlType.description; // => undefined
+ * introspection.__schema.description; // => undefined
+ * deprecatedDirective.isRepeatable; // => undefined
+ * ```
+ */
+export declare function introspectionFromSchema(schema: GraphQLSchema, options?: IntrospectionOptions): IntrospectionQuery;
+/**
+ * Build a GraphQLSchema for use by client tools.
+ *
+ * Given the result of a client running the introspection query, creates and
+ * returns a GraphQLSchema instance which can be then used with all graphql-js
+ * tools, but cannot be used to execute a query, as introspection does not
+ * represent the "resolver", "parse" or "serialize" functions or any other
+ * server-internal mechanisms.
+ *
+ * This function expects a complete introspection result. Don't forget to check
+ * the "errors" field of a server response before calling this function.
+ * @param introspection - Introspection result data to build from.
+ * @param options - Optional configuration for this operation.
+ * @returns The client schema represented by the introspection result.
+ * @example
+ * ```ts
+ * import {
+ *   buildClientSchema,
+ *   introspectionFromSchema,
+ *   buildSchema,
+ * } from 'graphql/utilities';
+ *
+ * const schema = buildSchema('type Query { hello: String }');
+ * const clientSchema = buildClientSchema(introspectionFromSchema(schema), {
+ *   assumeValid: true,
+ * });
+ *
+ * clientSchema.getQueryType().name; // => 'Query'
+ * ```
+ */
+export declare function buildClientSchema(introspection: IntrospectionQuery, options?: GraphQLSchemaValidationOptions): GraphQLSchema;
+/** Options used when building a schema from SDL or a parsed SDL document. */
+export interface BuildSchemaOptions extends GraphQLSchemaValidationOptions {
+	/**
+	 * Set to true to assume the SDL is valid.
+	 *
+	 * Default: false
+	 */
+	assumeValidSDL?: boolean | undefined;
+}
+/**
+ * Builds a GraphQLSchema from a parsed schema definition language document.
+ *
+ * If no schema definition is provided, then it will look for types named Query,
+ * Mutation and Subscription.
+ *
+ * The resulting schema has no resolver functions, so execution will use the
+ * default field resolver.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param options - Optional configuration for this operation.
+ * @returns The schema built from the provided SDL document.
+ * @example
+ * ```ts
+ * // Build a schema from a valid parsed SDL document.
+ * import { parse } from 'graphql/language';
+ * import { buildASTSchema } from 'graphql/utilities';
+ *
+ * const document = parse('type Query { hello: String }');
+ * const schema = buildASTSchema(document);
+ *
+ * schema.getQueryType().name; // => 'Query'
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses validation options when the SDL references unknown types.
+ * import { parse } from 'graphql/language';
+ * import { buildASTSchema } from 'graphql/utilities';
+ *
+ * const document = parse('type Query { broken: MissingType }');
+ *
+ * buildASTSchema(document); // throws an error
+ * buildASTSchema(document, {
+ *   assumeValid: true,
+ *   assumeValidSDL: true,
+ * }); // does not throw
+ * ```
+ */
+export declare function buildASTSchema(documentAST: DocumentNode, options?: BuildSchemaOptions): GraphQLSchema;
+/**
+ * Builds a GraphQLSchema directly from a schema definition language source.
+ * @param source - The GraphQL source text or source object.
+ * @param options - Optional configuration for this operation.
+ * @returns The schema built from the provided SDL document.
+ * @example
+ * ```ts
+ * // Build a schema from SDL source using the default options.
+ * import { buildSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema('type Query { hello: String }');
+ *
+ * schema.getQueryType().name; // => 'Query'
+ * ```
+ * @example
+ * ```ts
+ * // This variant enables parser options and omits source locations.
+ * import { buildSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(
+ *   'directive @tag on FIELD_DEFINITION\n' +
+ *     'directive @compose @tag on FIELD_DEFINITION',
+ *   {
+ *     experimentalFragmentArguments: true,
+ *     noLocation: true,
+ *   },
+ * );
+ *
+ * const directive = schema.getDirective('compose');
+ *
+ * directive.name; // => 'compose'
+ * directive.astNode.loc; // => undefined
+ * ```
+ */
+export declare function buildSchema(source: string | Source, options?: BuildSchemaOptions & ParseOptions): GraphQLSchema;
+interface Options extends GraphQLSchemaValidationOptions {
+	/**
+	 * Set to true to assume the SDL is valid.
+	 *
+	 * Default: false
+	 *
+	 * @internal
+	 */
+	assumeValidSDL?: boolean | undefined;
+}
+/**
+ * Produces a new schema given an existing schema and a document which may
+ * contain GraphQL type extensions and definitions. The original schema will
+ * remain unaltered.
+ *
+ * Because a schema represents a graph of references, a schema cannot be
+ * extended without effectively making an entire copy. We do not know until it's
+ * too late if subgraphs remain unchanged.
+ *
+ * This algorithm copies the provided schema, applying extensions while
+ * producing the copy. The original schema remains unaltered.
+ * @param schema - GraphQL schema to use.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param options - Optional configuration for this operation.
+ * @returns A new schema with the extensions and definitions applied.
+ * @example
+ * ```ts
+ * // Extend a schema with new fields and types.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema, extendSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const extensionAST = parse(`
+ *   extend type Query {
+ *     farewell: String
+ *   }
+ *
+ *   type Review {
+ *     body: String
+ *   }
+ * `);
+ *
+ * const extendedSchema = extendSchema(schema, extensionAST);
+ *
+ * schema.getType('Review'); // => undefined
+ * extendedSchema.getType('Review')?.name; // => 'Review'
+ * Object.keys(extendedSchema.getQueryType().getFields()); // => ['greeting', 'farewell']
+ * ```
+ * @example
+ * ```ts
+ * // This variant bypasses validation for an otherwise invalid extension.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema, extendSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const invalidExtension = parse(`
+ *   extend type Missing {
+ *     field: String
+ *   }
+ * `);
+ *
+ * extendSchema(schema, invalidExtension); // throws an error
+ * extendSchema(schema, invalidExtension, {
+ *   assumeValid: true,
+ *   assumeValidSDL: true,
+ * }); // does not throw
+ * ```
+ */
+export declare function extendSchema(schema: GraphQLSchema, documentAST: DocumentNode, options?: Options): GraphQLSchema;
+/**
+ * Sort GraphQLSchema.
+ *
+ * This function returns a sorted copy of the given GraphQLSchema.
+ * @param schema - GraphQL schema to use.
+ * @returns A copy of the schema with types, fields, arguments, and values sorted lexicographically.
+ * @example
+ * ```ts
+ * import {
+ *   buildSchema,
+ *   lexicographicSortSchema,
+ *   printSchema,
+ * } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     zebra: String
+ *     apple: String
+ *   }
+ *
+ *   enum Episode {
+ *     JEDI
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ * `);
+ *
+ * const sortedSchema = lexicographicSortSchema(schema);
+ *
+ * printSchema(sortedSchema);
+ * // =>
+ * // enum Episode {
+ * //   EMPIRE
+ * //   JEDI
+ * //   NEW_HOPE
+ * // }
+ * //
+ * // type Query {
+ * //   apple: String
+ * //   zebra: String
+ * // }
+ * ```
+ */
+export declare function lexicographicSortSchema(schema: GraphQLSchema): GraphQLSchema;
+/**
+ * Prints the schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   directive @upper on FIELD_DEFINITION
+ *
+ *   type Query {
+ *     greeting: String @upper
+ *   }
+ * `);
+ *
+ * printSchema(schema); // => ['directive @upper on FIELD_DEFINITION', '', 'type Query {', '  greeting: String', '}'].join('\n')
+ * ```
+ */
+export declare function printSchema(schema: GraphQLSchema): string;
+/**
+ * Prints the introspection schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printIntrospectionSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const printed = printIntrospectionSchema(schema);
+ *
+ * printed; // matches /type __Schema/
+ * printed; // matches /enum __TypeKind/
+ * printed; // does not match /type Query/
+ * ```
+ */
+export declare function printIntrospectionSchema(schema: GraphQLSchema): string;
+/**
+ * Prints the type.
+ * @param type - The GraphQL type to inspect.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printType } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     id: ID!
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     viewer: User
+ *   }
+ * `);
+ *
+ * printType(schema.getType('User')); // => ['type User {', '  id: ID!', '  name: String', '}'].join('\n')
+ * ```
+ */
+export declare function printType(type: GraphQLNamedType): string;
+/**
+ * Prints a directive definition in GraphQL SDL.
+ * @param directive - Directive to print.
+ * @returns SDL string for the directive definition.
+ * @example
+ * ```ts
+ * import {
+ *   DirectiveLocation,
+ *   GraphQLDirective,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { printDirective } from 'graphql/utilities';
+ *
+ * const authDirective = new GraphQLDirective({
+ *   name: 'auth',
+ *   description: 'Requires authorization.',
+ *   locations: [DirectiveLocation.FIELD_DEFINITION],
+ *   args: {
+ *     scope: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * printDirective(authDirective); // => '"""Requires authorization."""\ndirective @auth(scope: String) on FIELD_DEFINITION'
+ * ```
+ */
+export declare function printDirective(directive: GraphQLDirective): string;
+/**
+ * Given a Schema and an AST node describing a type, return a GraphQLType
+ * definition which applies to that type. For example, if provided the parsed
+ * AST node for `[User]`, a GraphQLList instance will be returned, containing
+ * the type called "User" found in the schema. If a type called "User" is not
+ * found in the schema, then undefined will be returned.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The GraphQL type AST node to resolve.
+ * @returns The GraphQL type referenced by the AST node, or undefined if it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('String'))?.toString(); // => 'String'
+ * typeFromAST(schema, parseType('Missing')); // => undefined
+ * ```
+ */
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: NamedTypeNode): GraphQLNamedType | undefined;
+/**
+ * Resolves a list type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The list type AST node to resolve.
+ * @returns The GraphQL list type referenced by the AST node, or undefined if
+ * it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     tags: [String]
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('[String]'))?.toString(); // => '[String]'
+ * typeFromAST(schema, parseType('[Missing]')); // => undefined
+ * ```
+ */
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: ListTypeNode): GraphQLList<any> | undefined;
+/**
+ * Resolves a non-null type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The non-null type AST node to resolve.
+ * @returns The GraphQL non-null type referenced by the AST node, or undefined
+ * if it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String!
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('String!'))?.toString(); // => 'String!'
+ * typeFromAST(schema, parseType('[String!]!'))?.toString(); // => '[String!]!'
+ * ```
+ */
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: NonNullTypeNode): GraphQLNonNull<any> | undefined;
+/**
+ * Resolves a type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The GraphQL type AST node to resolve.
+ * @returns The GraphQL type referenced by the AST node, or undefined if it
+ * cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     users: [User!]!
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('User'))?.toString(); // => 'User'
+ * typeFromAST(schema, parseType('[User!]!'))?.toString(); // => '[User!]!'
+ * typeFromAST(schema, parseType('Missing')); // => undefined
+ * ```
+ */
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: TypeNode): GraphQLType | undefined;
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * This deprecated function will be removed in v18. Use `coerceInputLiteral()`
+ * instead.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param type - The GraphQL type to inspect.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns The coerced JavaScript value, or undefined if the AST value cannot be coerced to the type.
+ * @example
+ * ```ts
+ * // Coerce literal values without variables.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * valueFromAST(parseValue('{ stars: 5, tags: ["featured"] }'), ReviewInput); // => { stars: 5, tags: ['featured'] }
+ * valueFromAST(parseValue('{ stars: "bad" }'), ReviewInput); // => undefined
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references from runtime values.
+ * import { parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * valueFromAST(parseValue('$stars'), GraphQLInt, { stars: 5 }); // => 5
+ * valueFromAST(parseValue('$stars'), GraphQLInt, {}); // => undefined
+ * ```
+ * @deprecated use `coerceInputLiteral()` instead - will be removed in v18
+ */
+export declare function valueFromAST(valueNode: Maybe<ValueNode>, type: GraphQLInputType, variables?: Maybe<ObjMap<unknown>>): unknown;
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * Because no GraphQL type is provided, the returned JavaScript value reflects
+ * the provided GraphQL value AST.
+ *
+ * | GraphQL Value        | JavaScript Value |
+ * | -------------------- | ---------------- |
+ * | Input Object         | Object           |
+ * | List                 | Array            |
+ * | Boolean              | Boolean          |
+ * | String / Enum        | String           |
+ * | Int / Float          | Number           |
+ * | Null                 | null             |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns JavaScript value represented by the GraphQL value AST.
+ * @example
+ * ```ts
+ * import { parseValue } from 'graphql/language';
+ * import { valueFromASTUntyped } from 'graphql/utilities';
+ *
+ * const value = valueFromASTUntyped(parseValue('[1, 2, 3]'));
+ *
+ * value; // => [1, 2, 3]
+ * valueFromASTUntyped(parseValue('$name'), { name: 'Ada' }); // => 'Ada'
+ * ```
+ */
+export declare function valueFromASTUntyped(valueNode: ValueNode, variables?: Maybe<ObjMap<unknown>>): unknown;
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using suggested GraphQLInputType.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * JavaScript values.
+ *
+ * This deprecated function will be removed in v18. Use `valueToLiteral()`
+ * instead, and take care to operate on external values.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String / Enum Value  |
+ * | Number        | Int / Float          |
+ * | BigInt        | Int                  |
+ * | Unknown       | Enum Value           |
+ * | null          | NullValue            |
+ * @param value - Runtime value to convert.
+ * @param type - The GraphQL type to inspect.
+ * @returns A GraphQL value AST for the provided JavaScript value, or null when no literal can represent it.
+ * @example
+ * ```ts
+ * import { print } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { astFromValue } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * const valueNode = astFromValue(
+ *   { stars: 5, tags: ['featured', 'verified'] },
+ *   ReviewInput,
+ * );
+ *
+ * print(valueNode); // => '{ stars: 5, tags: ["featured", "verified"] }'
+ * astFromValue(undefined, GraphQLString); // => null
+ * astFromValue(null, new GraphQLNonNull(GraphQLString)); // => null
+ * ```
+ * @deprecated use `valueToLiteral()` instead with care to operate on external values - `astFromValue()` will be removed in v18
+ */
+export declare function astFromValue(value: unknown, type: GraphQLInputType): Maybe<ConstValueNode>;
+/**
+ * Replaces any Variables found within an AST Value literal with literals
+ * supplied from a map of variable values, or removed if no variable replacement
+ * exists, returning a constant value.
+ *
+ * Used primarily to ensure only complete constant values are used during input
+ * coercion of custom scalars which accept complex literals.
+ * @param valueNode - Value AST node in which variables should be replaced.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @returns A constant value AST with variables replaced.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse, parseValue, print } from 'graphql/language';
+ * import { getVariableValues } from 'graphql/execution';
+ * import { buildSchema, replaceVariables } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     review(stars: Int = 5): String
+ *   }
+ * `);
+ * const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
+ * const operation = document.definitions[0];
+ * const result = getVariableValues(schema, operation.variableDefinitions, {
+ *   stars: 4,
+ * });
+ *
+ * assert('variableValues' in result);
+ *
+ * const literal = replaceVariables(
+ *   parseValue('{ stars: $stars, comment: $missing }'),
+ *   result.variableValues,
+ * );
+ *
+ * print(literal); // => '{ stars: 4 }'
+ * ```
+ */
+export declare function replaceVariables(valueNode: ValueNode, variableValues?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>): ConstValueNode;
+/**
+ * Produces a GraphQL Value AST given a JavaScript value and a GraphQL type.
+ *
+ * Scalar types are converted by calling the `valueToLiteral` method on that
+ * type, otherwise the default scalar `valueToLiteral` method is used, defined
+ * below.
+ *
+ * Provided value is a non-coerced "input" value. This function does not
+ * perform any coercion, however it does perform validation. Provided values
+ * which are invalid for the given type will result in an `undefined` return
+ * value.
+ * @param value - JavaScript value to convert.
+ * @param type - GraphQL input type to convert the value against.
+ * @returns A GraphQL value AST, or undefined if the value is invalid.
+ * @example
+ * ```ts
+ * import { print } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { valueToLiteral } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * const literal = valueToLiteral({ stars: 5, tags: ['featured'] }, ReviewInput);
+ *
+ * print(literal); // => '{ stars: 5, tags: ["featured"] }'
+ * valueToLiteral({ tags: ['missing stars'] }, ReviewInput); // => undefined
+ * ```
+ */
+export declare function valueToLiteral(value: unknown, type: GraphQLInputType): ConstValueNode | undefined;
+/**
+ * Coerces a JavaScript value given a GraphQL Input Type.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type. Use `validateInputValue` when coercion diagnostics
+ * are needed.
+ * @param inputValue - JavaScript value to coerce.
+ * @param type - GraphQL input type to coerce the value against.
+ * @returns Coerced value, or undefined if coercion fails.
+ * @example
+ * ```ts
+ * // Coerce runtime input values, returning undefined when coercion fails.
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { coerceInputValue } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * coerceInputValue({ stars: '5', tags: ['featured'] }, ReviewInput); // => { stars: 5, tags: ['featured'] }
+ * coerceInputValue({ stars: 'bad' }, ReviewInput); // => undefined
+ * ```
+ */
+export declare function coerceInputValue(inputValue: unknown, type: GraphQLInputType): unknown;
+/**
+ * Produces a coerced "internal" JavaScript value given a GraphQL Value AST.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ * @param valueNode - GraphQL value AST node to coerce.
+ * @param type - GraphQL input type to coerce the literal against.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @returns Coerced value, or undefined if coercion fails.
+ * @example
+ * ```ts
+ * // Coerce literal input values without variables.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { coerceInputLiteral } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     comment: { type: GraphQLString },
+ *   },
+ * });
+ *
+ * coerceInputLiteral(
+ *   parseValue('{ stars: 5, comment: "Loved it" }'),
+ *   ReviewInput,
+ * ); // => { stars: 5, comment: 'Loved it' }
+ * coerceInputLiteral(parseValue('{ comment: "Missing" }'), ReviewInput); // => undefined
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references using VariableValues from getVariableValues().
+ * import assert from 'node:assert';
+ * import { parse, parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { getVariableValues } from 'graphql/execution';
+ * import { buildSchema, coerceInputLiteral } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     review(stars: Int): String
+ *   }
+ * `);
+ * const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
+ * const operation = document.definitions[0];
+ * const result = getVariableValues(schema, operation.variableDefinitions, {
+ *   stars: '4',
+ * });
+ *
+ * assert('variableValues' in result);
+ *
+ * coerceInputLiteral(parseValue('$stars'), GraphQLInt, result.variableValues); // => 4
+ * ```
+ */
+export declare function coerceInputLiteral(valueNode: ValueNode, type: GraphQLInputType, variableValues?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>): unknown;
+/**
+ * Validate that the provided input value is allowed for this type, collecting
+ * all errors via a callback function.
+ * @param inputValue - JavaScript value to validate.
+ * @param type - GraphQL input type to validate the value against.
+ * @param onError - Callback invoked for each validation error and path.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns Nothing.
+ * @example
+ * ```ts
+ * // Collect validation errors with their input paths.
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLNonNull,
+ * } from 'graphql/type';
+ * import { validateInputValue } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *   },
+ * });
+ * const errors = [];
+ *
+ * validateInputValue({ stars: 'bad' }, ReviewInput, (error, path) => {
+ *   errors.push({ message: error.message, path });
+ * });
+ *
+ * errors; // => [ { message: 'Expected value of type "Int", found: "bad".', path: ['stars'] } ]
+ * ```
+ * @example
+ * ```ts
+ * // This variant hides suggestion text for unknown input fields.
+ * import { GraphQLInputObjectType, GraphQLString } from 'graphql/type';
+ * import { validateInputValue } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     comment: { type: GraphQLString },
+ *   },
+ * });
+ * const errors = [];
+ *
+ * validateInputValue(
+ *   { rating: 'extra field' },
+ *   ReviewInput,
+ *   (error) => {
+ *     errors.push(error.message);
+ *   },
+ *   true,
+ * );
+ *
+ * errors; // => ['Expected value of type "ReviewInput" not to include unknown field "rating", found: { rating: "extra field" }.']
+ * ```
+ */
+export declare function validateInputValue(inputValue: unknown, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, hideSuggestions?: Maybe<boolean>): void;
+/**
+ * Validate that the provided input literal is allowed for this type, collecting
+ * all errors via a callback function.
+ *
+ * If variable values are not provided, the literal is validated statically
+ * (not assuming that those variables are missing runtime values).
+ * @param valueNode - GraphQL value AST node to validate.
+ * @param type - GraphQL input type to validate the literal against.
+ * @param onError - Callback invoked for each validation error and path.
+ * @param variables - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns Nothing.
+ * @example
+ * ```ts
+ * // Validate literal input values and collect literal paths.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLNonNull,
+ * } from 'graphql/type';
+ * import { validateInputLiteral } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *   },
+ * });
+ * const errors = [];
+ *
+ * validateInputLiteral(
+ *   parseValue('{ stars: "bad" }'),
+ *   ReviewInput,
+ *   (error, path) => {
+ *     errors.push({ message: error.message, path });
+ *   },
+ * );
+ *
+ * errors; // => [ { message: 'Expected value of type "Int", found: "bad".', path: ['stars'] } ]
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references using VariableValues from getVariableValues().
+ * import assert from 'node:assert';
+ * import { parse, parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { getVariableValues } from 'graphql/execution';
+ * import { buildSchema, validateInputLiteral } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     review(stars: Int): String
+ *   }
+ * `);
+ * const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
+ * const operation = document.definitions[0];
+ * const result = getVariableValues(schema, operation.variableDefinitions, {
+ *   stars: '4',
+ * });
+ *
+ * assert('variableValues' in result);
+ *
+ * const errors = [];
+ * validateInputLiteral(
+ *   parseValue('$stars'),
+ *   GraphQLInt,
+ *   (error) => errors.push(error.message),
+ *   result.variableValues,
+ *   undefined,
+ *   true,
+ * );
+ *
+ * errors; // => []
+ * ```
+ */
+export declare function validateInputLiteral(valueNode: ValueNode, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, variables?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): void;
+/**
+ * Provided a collection of ASTs, presumably each from different files,
+ * concatenate the ASTs together into batched AST, useful for validating many
+ * GraphQL source files which together represent one conceptual application.
+ * @param documents - Document ASTs to concatenate.
+ * @returns A document AST containing all definitions from the provided documents.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { concatAST } from 'graphql/utilities';
+ *
+ * const document = concatAST([
+ *   parse('type Query { a: String }'),
+ *   parse('type User { id: ID }'),
+ * ]);
+ *
+ * document.definitions.length; // => 2
+ * ```
+ */
+export declare function concatAST(documents: ReadonlyArray<DocumentNode>): DocumentNode;
+/**
+ * separateOperations accepts a single AST document which may contain many
+ * operations and fragments and returns a collection of AST documents each of
+ * which contains a single operation as well the fragment definitions it
+ * refers to.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @returns A map of operation names to documents containing each operation and its referenced fragments.
+ * @example
+ * ```ts
+ * import { parse, print } from 'graphql/language';
+ * import { separateOperations } from 'graphql/utilities';
+ *
+ * const document = parse(`
+ *   query GetUser {
+ *     viewer {
+ *       ...UserFields
+ *     }
+ *   }
+ *
+ *   query GetStatus {
+ *     status
+ *   }
+ *
+ *   fragment UserFields on User {
+ *     id
+ *   }
+ * `);
+ *
+ * const separated = separateOperations(document);
+ *
+ * Object.keys(separated); // => ['GetUser', 'GetStatus']
+ * print(separated.GetUser); // matches /fragment UserFields/
+ * print(separated.GetStatus); // does not match /fragment UserFields/
+ * ```
+ */
+export declare function separateOperations(documentAST: DocumentNode): ObjMap<DocumentNode>;
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ * @param source - The GraphQL source text or source object.
+ * @returns A semantically equivalent GraphQL source string without ignored characters.
+ * @example Query source
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql prettier-ignore
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ * @example SDL source
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql prettier-ignore
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ * @example
+ * ```ts
+ * import { stripIgnoredCharacters } from 'graphql/utilities';
+ *
+ * const source = stripIgnoredCharacters('query Example { name }');
+ *
+ * source; // => 'query Example{name}'
+ * ```
+ */
+export declare function stripIgnoredCharacters(source: string | Source): string;
+/**
+ * Provided two types, return true if the types are equal (invariant).
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when both types are equal.
+ * @example
+ * ```ts
+ * import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';
+ * import { isEqualType } from 'graphql/utilities';
+ *
+ * isEqualType(GraphQLString, GraphQLString); // => true
+ * isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true
+ * isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false
+ * ```
+ */
+export declare function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean;
+/**
+ * Provided a type and a super type, return true if the first type is either
+ * equal or a subset of the second super type (covariant).
+ * @param schema - GraphQL schema to use.
+ * @param maybeSubType - The possible subtype to compare.
+ * @param superType - The possible supertype to compare.
+ * @returns True when `maybeSubType` is equal to or a subtype of `superType`.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   GraphQLNonNull,
+ *   assertInterfaceType,
+ *   assertObjectType,
+ * } from 'graphql/type';
+ * import { isTypeSubTypeOf } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ * const Node = assertInterfaceType(schema.getType('Node'));
+ * const User = assertObjectType(schema.getType('User'));
+ *
+ * isTypeSubTypeOf(schema, User, Node); // => true
+ * isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true
+ * isTypeSubTypeOf(schema, Node, User); // => false
+ * ```
+ */
+export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: GraphQLType, superType: GraphQLType): boolean;
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ * @param schema - GraphQL schema to use.
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when the two composite types can apply to at least one common object type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertObjectType, assertUnionType } from 'graphql/type';
+ * import { doTypesOverlap } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Photo {
+ *     url: String!
+ *   }
+ *
+ *   type Video {
+ *     url: String!
+ *   }
+ *
+ *   union Media = Photo | Video
+ *   union StillImage = Photo
+ *
+ *   type Query {
+ *     media: [Media]
+ *   }
+ * `);
+ * const Media = assertUnionType(schema.getType('Media'));
+ * const StillImage = assertUnionType(schema.getType('StillImage'));
+ * const Video = assertObjectType(schema.getType('Video'));
+ *
+ * doTypesOverlap(schema, Media, StillImage); // => true
+ * doTypesOverlap(schema, StillImage, Video); // => false
+ * ```
+ */
+export declare function doTypesOverlap(schema: GraphQLSchema, typeA: GraphQLCompositeType, typeB: GraphQLCompositeType): boolean;
+/** Categories of schema changes that may break existing operations. */
+export declare const BreakingChangeType: {
+	readonly TYPE_REMOVED: "TYPE_REMOVED";
+	readonly TYPE_CHANGED_KIND: "TYPE_CHANGED_KIND";
+	readonly TYPE_REMOVED_FROM_UNION: "TYPE_REMOVED_FROM_UNION";
+	readonly VALUE_REMOVED_FROM_ENUM: "VALUE_REMOVED_FROM_ENUM";
+	readonly REQUIRED_INPUT_FIELD_ADDED: "REQUIRED_INPUT_FIELD_ADDED";
+	readonly IMPLEMENTED_INTERFACE_REMOVED: "IMPLEMENTED_INTERFACE_REMOVED";
+	readonly FIELD_REMOVED: "FIELD_REMOVED";
+	readonly FIELD_CHANGED_KIND: "FIELD_CHANGED_KIND";
+	readonly REQUIRED_ARG_ADDED: "REQUIRED_ARG_ADDED";
+	readonly ARG_REMOVED: "ARG_REMOVED";
+	readonly ARG_CHANGED_KIND: "ARG_CHANGED_KIND";
+	readonly DIRECTIVE_REMOVED: "DIRECTIVE_REMOVED";
+	readonly DIRECTIVE_ARG_REMOVED: "DIRECTIVE_ARG_REMOVED";
+	readonly REQUIRED_DIRECTIVE_ARG_ADDED: "REQUIRED_DIRECTIVE_ARG_ADDED";
+	readonly DIRECTIVE_REPEATABLE_REMOVED: "DIRECTIVE_REPEATABLE_REMOVED";
+	readonly DIRECTIVE_LOCATION_REMOVED: "DIRECTIVE_LOCATION_REMOVED";
+};
+/** Categories of schema changes that may break existing operations. */
+export type BreakingChangeType = (typeof BreakingChangeType)[keyof typeof BreakingChangeType];
+/** Categories of schema changes that may be dangerous for existing operations. */
+export declare const DangerousChangeType: {
+	readonly VALUE_ADDED_TO_ENUM: "VALUE_ADDED_TO_ENUM";
+	readonly TYPE_ADDED_TO_UNION: "TYPE_ADDED_TO_UNION";
+	readonly OPTIONAL_INPUT_FIELD_ADDED: "OPTIONAL_INPUT_FIELD_ADDED";
+	readonly OPTIONAL_ARG_ADDED: "OPTIONAL_ARG_ADDED";
+	readonly IMPLEMENTED_INTERFACE_ADDED: "IMPLEMENTED_INTERFACE_ADDED";
+	readonly ARG_DEFAULT_VALUE_CHANGE: "ARG_DEFAULT_VALUE_CHANGE";
+	readonly INPUT_FIELD_DEFAULT_VALUE_CHANGE: "INPUT_FIELD_DEFAULT_VALUE_CHANGE";
+};
+/** Categories of schema changes that may be dangerous for existing operations. */
+export type DangerousChangeType = (typeof DangerousChangeType)[keyof typeof DangerousChangeType];
+/** Categories of schema changes that are considered safe for existing operations. */
+export declare const SafeChangeType: {
+	readonly DESCRIPTION_CHANGED: "DESCRIPTION_CHANGED";
+	readonly TYPE_ADDED: "TYPE_ADDED";
+	readonly OPTIONAL_INPUT_FIELD_ADDED: "OPTIONAL_INPUT_FIELD_ADDED";
+	readonly OPTIONAL_ARG_ADDED: "OPTIONAL_ARG_ADDED";
+	readonly DIRECTIVE_ADDED: "DIRECTIVE_ADDED";
+	readonly FIELD_ADDED: "FIELD_ADDED";
+	readonly DIRECTIVE_REPEATABLE_ADDED: "DIRECTIVE_REPEATABLE_ADDED";
+	readonly DIRECTIVE_LOCATION_ADDED: "DIRECTIVE_LOCATION_ADDED";
+	readonly OPTIONAL_DIRECTIVE_ARG_ADDED: "OPTIONAL_DIRECTIVE_ARG_ADDED";
+	readonly FIELD_CHANGED_KIND_SAFE: "FIELD_CHANGED_KIND_SAFE";
+	readonly ARG_CHANGED_KIND_SAFE: "ARG_CHANGED_KIND_SAFE";
+	readonly ARG_DEFAULT_VALUE_ADDED: "ARG_DEFAULT_VALUE_ADDED";
+	readonly INPUT_FIELD_DEFAULT_VALUE_ADDED: "INPUT_FIELD_DEFAULT_VALUE_ADDED";
+};
+/** Categories of schema changes that are considered safe for existing operations. */
+export type SafeChangeType = (typeof SafeChangeType)[keyof typeof SafeChangeType];
+/** Description of a schema change that may break existing operations. */
+export interface BreakingChange {
+	/** Specific kind of breaking schema change. */
+	type: BreakingChangeType;
+	/** Human-readable description of the breaking schema change. */
+	description: string;
+}
+/** Description of a schema change that may be dangerous for existing operations. */
+export interface DangerousChange {
+	/** Specific kind of dangerous schema change. */
+	type: DangerousChangeType;
+	/** Human-readable description of the dangerous schema change. */
+	description: string;
+}
+/** Description of a schema change that is considered safe for existing operations. */
+export interface SafeChange {
+	/** Specific kind of safe schema change. */
+	type: SafeChangeType;
+	/** Human-readable description of the safe schema change. */
+	description: string;
+}
+/** Any schema change detected between two schemas. */
+export type SchemaChange = SafeChange | DangerousChange | BreakingChange;
+/**
+ * Given two schemas, returns an Array containing descriptions of all the types
+ * of breaking changes covered by the other functions down below. This
+ * deprecated wrapper will be removed in v18; use `findSchemaChanges()` instead
+ * and filter for breaking changes.
+ * @param oldSchema - Schema before the change.
+ * @param newSchema - Schema after the change.
+ * @returns Breaking changes between the two schemas.
+ * @example
+ * ```ts
+ * import { buildSchema, findBreakingChanges } from 'graphql/utilities';
+ *
+ * const oldSchema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const newSchema = buildSchema(`
+ *   type Query {
+ *     hello: String
+ *   }
+ * `);
+ *
+ * const changes = findBreakingChanges(oldSchema, newSchema);
+ *
+ * changes.map((change) => change.type); // => ['FIELD_REMOVED']
+ * ```
+ * @deprecated Please use `findSchemaChanges` instead. Will be removed in v18.
+ */
+export declare function findBreakingChanges(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Array<BreakingChange>;
+/**
+ * Given two schemas, returns an Array containing descriptions of all the types
+ * of potentially dangerous changes covered by the other functions down below.
+ * This deprecated wrapper will be removed in v18; use `findSchemaChanges()`
+ * instead and filter for dangerous changes.
+ * @param oldSchema - Schema before the change.
+ * @param newSchema - Schema after the change.
+ * @returns Dangerous changes between the two schemas.
+ * @example
+ * ```ts
+ * import { buildSchema, findDangerousChanges } from 'graphql/utilities';
+ *
+ * const oldSchema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *   }
+ *
+ *   type Query {
+ *     episode: Episode
+ *   }
+ * `);
+ * const newSchema = buildSchema(`
+ *   enum Episode {
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ *
+ *   type Query {
+ *     episode: Episode
+ *   }
+ * `);
+ *
+ * const changes = findDangerousChanges(oldSchema, newSchema);
+ *
+ * changes.map((change) => change.type); // => ['VALUE_ADDED_TO_ENUM']
+ * ```
+ * @deprecated Please use `findSchemaChanges` instead. Will be removed in v18.
+ */
+export declare function findDangerousChanges(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Array<DangerousChange>;
+/**
+ * Finds all schema changes between two schemas.
+ * @param oldSchema - Schema before the change.
+ * @param newSchema - Schema after the change.
+ * @returns Safe, dangerous, and breaking changes between the two schemas.
+ * @example
+ * ```ts
+ * import { buildSchema, findSchemaChanges } from 'graphql/utilities';
+ *
+ * const oldSchema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ * const newSchema = buildSchema(`
+ *   type Query {
+ *     greeting(name: String): String
+ *     farewell: String
+ *   }
+ * `);
+ *
+ * const changes = findSchemaChanges(oldSchema, newSchema);
+ *
+ * changes.map((change) => change.type); // => ['OPTIONAL_ARG_ADDED', 'FIELD_ADDED']
+ * ```
+ */
+export declare function findSchemaChanges(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Array<SchemaChange>;
+/**
+ * Wrapper type that contains DocumentNode and types that can be deduced from it.
+ * @typeParam TResponseData - Typed GraphQL response data shape.
+ * @typeParam TRequestVariables - Typed GraphQL request variables shape.
+ */
+export interface TypedQueryDocumentNode<TResponseData = {
+	[key: string]: any;
+}, TRequestVariables = {
+	[key: string]: any;
+}> extends DocumentNode {
+	/** Top-level executable and type-system definitions in this document. */
+	readonly definitions: ReadonlyArray<ExecutableDefinitionNode>;
+	/**
+	 * This type is used to ensure that the variables you pass in to the query are assignable to Variables
+	 * and that the Result is assignable to whatever you pass your result to. The method is never actually
+	 * implemented, but the type is valid because we list it as optional
+	 */
+	__ensureTypesOfVariablesAndResultMatching?: (variables: TRequestVariables) => TResponseData;
+}
+interface ResolvedNamedType {
+	readonly kind: "NamedType";
+	readonly type: GraphQLNamedType;
+}
+interface ResolvedField {
+	readonly kind: "Field";
+	readonly type: GraphQLObjectType | GraphQLInterfaceType;
+	readonly field: GraphQLField<unknown, unknown>;
+}
+interface ResolvedInputField {
+	readonly kind: "InputField";
+	readonly type: GraphQLInputObjectType;
+	readonly inputField: GraphQLInputField;
+}
+interface ResolvedEnumValue {
+	readonly kind: "EnumValue";
+	readonly type: GraphQLEnumType;
+	readonly enumValue: GraphQLEnumValue;
+}
+interface ResolvedFieldArgument {
+	readonly kind: "FieldArgument";
+	readonly type: GraphQLObjectType | GraphQLInterfaceType;
+	readonly field: GraphQLField<unknown, unknown>;
+	readonly fieldArgument: GraphQLArgument;
+}
+interface ResolvedDirective {
+	readonly kind: "Directive";
+	readonly directive: GraphQLDirective;
+}
+interface ResolvedDirectiveArgument {
+	readonly kind: "DirectiveArgument";
+	readonly directive: GraphQLDirective;
+	readonly directiveArgument: GraphQLArgument;
+}
+/** A schema element resolved from a schema coordinate. */
+export type ResolvedSchemaElement = ResolvedNamedType | ResolvedField | ResolvedInputField | ResolvedEnumValue | ResolvedFieldArgument | ResolvedDirective | ResolvedDirectiveArgument;
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ * @param schema - GraphQL schema to use.
+ * @param schemaCoordinate - The schema coordinate to resolve.
+ * @returns The schema element identified by the coordinate, or undefined if none exists.
+ * @example
+ * ```ts
+ * import { buildSchema, resolveSchemaCoordinate } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   directive @tag(name: String!) on FIELD_DEFINITION
+ *
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   enum Episode {
+ *     NEW_HOPE
+ *   }
+ *
+ *   type Query {
+ *     reviews(input: ReviewInput): [String] @tag(name: "reviews")
+ *   }
+ * `);
+ *
+ * resolveSchemaCoordinate(schema, 'Query').kind; // => 'NamedType'
+ * resolveSchemaCoordinate(schema, 'Query.reviews').kind; // => 'Field'
+ * resolveSchemaCoordinate(schema, 'Query.reviews(input:)').kind; // => 'FieldArgument'
+ * resolveSchemaCoordinate(schema, 'ReviewInput.stars').kind; // => 'InputField'
+ * resolveSchemaCoordinate(schema, 'Episode.NEW_HOPE').kind; // => 'EnumValue'
+ * resolveSchemaCoordinate(schema, '@tag').kind; // => 'Directive'
+ * resolveSchemaCoordinate(schema, '@tag(name:)').kind; // => 'DirectiveArgument'
+ * resolveSchemaCoordinate(schema, 'Query.missing'); // => undefined
+ * ```
+ */
+export declare function resolveSchemaCoordinate(schema: GraphQLSchema, schemaCoordinate: string | Source): ResolvedSchemaElement | undefined;
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ * @param schema - GraphQL schema to use.
+ * @param schemaCoordinate - The schema coordinate to resolve.
+ * @returns The schema element identified by the parsed coordinate, or undefined if none exists.
+ * @example
+ * ```ts
+ * import { parseSchemaCoordinate } from 'graphql/language';
+ * import { buildSchema, resolveASTSchemaCoordinate } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting(name: String): String
+ *   }
+ * `);
+ * const coordinate = parseSchemaCoordinate('Query.greeting(name:)');
+ * const resolved = resolveASTSchemaCoordinate(schema, coordinate);
+ *
+ * resolved.kind; // => 'FieldArgument'
+ * resolved.field.name; // => 'greeting'
+ * resolved.fieldArgument.name; // => 'name'
+ * ```
+ */
+export declare function resolveASTSchemaCoordinate(schema: GraphQLSchema, schemaCoordinate: SchemaCoordinateNode): ResolvedSchemaElement | undefined;
+type ExtensionsObject = Record<string | symbol, any>;
+type ObjectTypeExtensions = {
+	type: "object";
+	fields: Record<string, {
+		extensions: ExtensionsObject;
+		arguments: Record<string, ExtensionsObject>;
+	}>;
+};
+type InputTypeExtensions = {
+	type: "input";
+	fields: Record<string, {
+		extensions: ExtensionsObject;
+	}>;
+};
+type InterfaceTypeExtensions = {
+	type: "interface";
+	fields: Record<string, {
+		extensions: ExtensionsObject;
+		arguments: Record<string, ExtensionsObject>;
+	}>;
+};
+type UnionTypeExtensions = {
+	type: "union";
+};
+type ScalarTypeExtensions = {
+	type: "scalar";
+};
+type EnumTypeExtensions = {
+	type: "enum";
+	values: Record<string, ExtensionsObject>;
+};
+type PossibleTypeExtensions = InputTypeExtensions | InterfaceTypeExtensions | ObjectTypeExtensions | UnionTypeExtensions | ScalarTypeExtensions | EnumTypeExtensions;
+type SchemaExtensions = {
+	schemaExtensions: ExtensionsObject;
+	types: Record<string, {
+		extensions: ExtensionsObject;
+	} & PossibleTypeExtensions>;
+};
+interface GraphQLResolveInfo$1 extends GraphQLResolveInfo {
+	signal?: AbortSignal;
+	/** Returns the AbortSignal supplied for this execution, if any. */
+	readonly getAbortSignal: () => AbortSignal | undefined;
+	/** Returns helper functions for tracking asynchronous resolver work. */
+	readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers$1;
+}
+interface GraphQLResolveInfoHelpers$1 {
+	/**
+	 * Promise.all wrapper that allows rejected branches to be tracked
+	 * as execution async work.
+	 *
+	 * Intended use: return or await this promise from resolver work.
+	 * Un-awaited async side effects are an anti-pattern:
+	 *
+	 *   const { promiseAll } = info.getAsyncHelpers();
+	 *   promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
+	 *
+	 * In that anti-pattern, tracking starts only after rejection (on a
+	 * later microtask), so this work is not guaranteed to delay
+	 * `hooks.asyncWorkFinished`.
+	 *
+	 * Use `track(...)` for un-awaited async side effects:
+	 *
+	 *   const { track } = info.getAsyncHelpers();
+	 *   track([
+	 *     someAsyncWork().catch(() => undefined),
+	 *     someOtherAsyncWork().catch(() => undefined)
+	 *   ]);
+	 */
+	readonly promiseAll: <T>(values: ReadonlyArray<PromiseLike<T> | T>) => Promise<Array<T>>;
+	/** Tracks asynchronous work that should delay execution completion hooks. */
+	readonly track: (maybePromises: ReadonlyArray<unknown>) => void;
+}
+interface GraphQLParseOptions {
+	noLocation?: boolean;
+	allowLegacySDLEmptyFields?: boolean;
+	allowLegacySDLImplementsInterfaces?: boolean;
+	experimentalFragmentVariables?: boolean;
+	/**
+	 * Set to `true` in order to convert all GraphQL comments (marked with # sign) to descriptions (""")
+	 * GraphQL has built-in support for transforming descriptions to comments (with `print`), but not while
+	 * parsing. Turning the flag on will support the other way as well (`parse`)
+	 */
+	commentDescriptions?: boolean;
+}
+type ValidatorBehavior = "error" | "warn" | "ignore";
+interface IResolverValidationOptions {
+	/**
+	 * Enable to require a resolver to be defined for any field that has
+	 * arguments. Defaults to `ignore`.
+	 */
+	requireResolversForArgs?: ValidatorBehavior;
+	/**
+	 * Enable to require a resolver to be defined for any field which has
+	 * a return type that isn't a scalar. Defaults to `ignore`.
+	 */
+	requireResolversForNonScalar?: ValidatorBehavior;
+	/**
+	 * Enable to require a resolver for be defined for all fields defined
+	 * in the schema. Defaults to `ignore`.
+	 */
+	requireResolversForAllFields?: ValidatorBehavior;
+	/**
+	 * Enable to require a `resolveType()` for Interface and Union types.
+	 * Defaults to `ignore`.
+	 */
+	requireResolversForResolveType?: ValidatorBehavior;
+	/**
+	 * Enable to require all defined resolvers to match fields that
+	 * actually exist in the schema. Defaults to `error` to catch common errors.
+	 */
+	requireResolversToMatchSchema?: ValidatorBehavior;
+}
+type IScalarTypeResolver = GraphQLScalarType & {
+	__name?: string;
+	__description?: string;
+	__serialize?: GraphQLScalarSerializer<any>;
+	__parseValue?: GraphQLScalarValueParser<any>;
+	__parseLiteral?: GraphQLScalarLiteralParser<any>;
+	__extensions?: ExtensionsObject;
+	__astNode?: ScalarTypeDefinitionNode;
+	__extensionASTNodes?: Array<ScalarTypeExtensionNode>;
+};
+type IEnumTypeResolver = Record<string, any> & {
+	__name?: string;
+	__description?: string;
+	__extensions?: ExtensionsObject;
+	__astNode?: EnumTypeDefinitionNode;
+	__extensionASTNodes?: Array<EnumTypeExtensionNode>;
+};
+interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
+	name?: string;
+	description?: string;
+	type?: GraphQLOutputType;
+	args?: Array<GraphQLArgument>;
+	resolve?: IFieldResolver<TSource, TContext, TArgs>;
+	subscribe?: IFieldResolver<TSource, TContext, TArgs>;
+	isDeprecated?: boolean;
+	deprecationReason?: string;
+	extensions?: ExtensionsObject;
+	astNode?: FieldDefinitionNode;
+}
+type IFieldResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo$1) => TReturn;
+type TypeSource = string | Source | DocumentNode | GraphQLSchema | DefinitionNode | Array<TypeSource> | (() => TypeSource);
+type IObjectTypeResolver<TSource = any, TContext = any, TArgs = any> = {
+	[key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
+} & {
+	__name?: string;
+	__description?: string;
+	__isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
+	__extensions?: ExtensionsObject;
+	__astNode?: ObjectTypeDefinitionNode;
+	__extensionASTNodes?: ObjectTypeExtensionNode;
+};
+type IInterfaceTypeResolver<TSource = any, TContext = any, TArgs = any> = {
+	[key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
+} & {
+	__name?: string;
+	__description?: string;
+	__resolveType?: GraphQLTypeResolver<any, any>;
+	__extensions?: ExtensionsObject;
+	__astNode?: InterfaceTypeDefinitionNode;
+	__extensionASTNodes?: Array<InterfaceTypeExtensionNode>;
+};
+type IUnionTypeResolver = {
+	__name?: string;
+	__description?: string;
+	__resolveType?: GraphQLTypeResolver<any, any>;
+	__extensions?: ExtensionsObject;
+	__astNode?: UnionTypeDefinitionNode;
+	__extensionASTNodes?: Array<UnionTypeExtensionNode>;
+};
+type IInputObjectTypeResolver = {
+	__name?: string;
+	__description?: string;
+	__extensions?: ExtensionsObject;
+	__astNode?: InputObjectTypeDefinitionNode;
+	__extensionASTNodes?: Array<InputObjectTypeExtensionNode>;
+};
+type ISchemaLevelResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = IFieldResolver<TSource, TContext, TArgs, TReturn>;
+type IResolvers<TSource = any, TContext = any, TArgs = Record<string, any>, TReturn = any> = Record<string, ISchemaLevelResolver<TSource, TContext, TArgs, TReturn> | IObjectTypeResolver<TSource, TContext> | IInterfaceTypeResolver<TSource, TContext> | IUnionTypeResolver | IScalarTypeResolver | IEnumTypeResolver | IInputObjectTypeResolver>;
+export interface GraphQLError {
+	/**
+	 * An optional schema coordinate (e.g. "MyType.myField") associated with this error.
+	 */
+	readonly coordinate?: string;
+}
+interface IExecutableSchemaDefinition<TContext = any> extends BuildSchemaOptions, GraphQLParseOptions {
+	/**
+	 * The type definitions used to create the schema
+	 */
+	typeDefs: TypeSource;
+	/**
+	 * Object describing the field resolvers for the provided type definitions
+	 */
+	resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
+	/**
+	 * Additional options for validating the provided resolvers
+	 */
+	resolverValidationOptions?: IResolverValidationOptions;
+	/**
+	 * GraphQL object types that implement interfaces will inherit any missing
+	 * resolvers from their interface types defined in the `resolvers` object
+	 */
+	inheritResolversFromInterfaces?: boolean;
+	/**
+	 * Do not create a schema again and use the one from `buildASTSchema`
+	 */
+	updateResolversInPlace?: boolean;
+	/**
+	 * Schema extensions
+	 */
+	schemaExtensions?: SchemaExtensions | Array<SchemaExtensions>;
+	/**
+	 * Default field resolver
+	 */
+	defaultFieldResolver?: GraphQLFieldResolver<any, TContext>;
+}
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use GraphQL magic comment provide additional syntax
+ * highlighting in your editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = /* GraphQL *\/ `
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
+export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, resolverValidationOptions, inheritResolversFromInterfaces, updateResolversInPlace, schemaExtensions, defaultFieldResolver, ...otherOptions }: IExecutableSchemaDefinition<TContext>): GraphQLSchema;
+type ID = string;
+declare enum MessageType {
+	ConnectionInit = "connection_init",// Client -> Server
+	ConnectionAck = "connection_ack",// Server -> Client
+	Ping = "ping",// bidirectional
+	Pong = "pong",/// bidirectional
+	Subscribe = "subscribe",// Client -> Server
+	Next = "next",// Server -> Client
+	Error = "error",// Server -> Client
+	Complete = "complete"
+}
+interface ConnectionInitMessage {
+	readonly type: MessageType.ConnectionInit;
+	readonly payload?: Record<string, unknown>;
+}
+interface PingMessage {
+	readonly type: MessageType.Ping;
+	readonly payload?: Record<string, unknown>;
+}
+interface PongMessage {
+	readonly type: MessageType.Pong;
+	readonly payload?: Record<string, unknown>;
+}
+interface SubscribePayload {
+	readonly operationName?: string | null | undefined;
+	readonly query: string;
+	readonly variables?: Record<string, unknown> | null | undefined;
+	readonly extensions?: Record<string, unknown> | null | undefined;
+}
+interface ExecutionResult$1<Data = Record<string, unknown>, Extensions = Record<string, unknown>> {
+	errors?: ReadonlyArray<GraphQLError> | undefined;
+	data?: Data | null | undefined;
+	hasNext?: boolean | undefined;
+	extensions?: Extensions | undefined;
+}
+type JSONMessageReviver = (this: any, key: string, value: any) => any;
+type JSONMessageReplacer = (this: any, key: string, value: any) => any;
+type OperationResult = Promise<AsyncGenerator<ExecutionResult$1> | AsyncIterable<ExecutionResult$1> | ExecutionResult$1> | AsyncGenerator<ExecutionResult$1> | AsyncIterable<ExecutionResult$1> | ExecutionResult$1;
+type GraphQLExecutionContextValue = object | symbol | number | string | boolean | undefined | null;
+/** @category Server */
+export interface ServerOptions<P extends ConnectionInitMessage["payload"] = ConnectionInitMessage["payload"], E = unknown> {
+	/**
+	 * The GraphQL schema on which the operations
+	 * will be executed and validated against.
+	 *
+	 * If a function is provided, it will be called on
+	 * every subscription request allowing you to manipulate
+	 * schema dynamically.
+	 *
+	 * If the schema is left undefined, you're trusted to
+	 * provide one in the returned `ExecutionArgs` from the
+	 * `onSubscribe` callback.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	schema?: undefined | GraphQLSchema | ((ctx: Context<P, E>, id: string, payload: SubscribePayload, args: Omit<ExecutionArgs, "schema">) => Promise<GraphQLSchema> | GraphQLSchema);
+	/**
+	 * A value which is provided to every resolver and holds
+	 * important contextual information like the currently
+	 * logged in user, or access to a database.
+	 *
+	 * If you return from `onSubscribe`, and the returned value is
+	 * missing the `contextValue` field, this context will be used
+	 * instead.
+	 *
+	 * If you use the function signature, the final execution arguments
+	 * will be passed in (also the returned value from `onSubscribe`).
+	 * Since the context is injected on every subscribe, the `SubscribeMessage`
+	 * with the regular `Context` will be passed in through the arguments too.
+	 *
+	 * Note that the context function is invoked on each operation only once.
+	 * Meaning, for subscriptions, only at the point of initialising the subscription;
+	 * not on every subscription event emission. Read more about the context lifecycle
+	 * in subscriptions here: https://github.com/graphql/graphql-js/issues/894.
+	 */
+	context?: undefined | GraphQLExecutionContextValue | ((ctx: Context<P, E>, id: string, payload: SubscribePayload, args: ExecutionArgs) => Promise<GraphQLExecutionContextValue> | GraphQLExecutionContextValue);
+	/**
+	 * The GraphQL root fields or resolvers to go
+	 * alongside the schema. Learn more about them
+	 * here: https://graphql.org/learn/execution/#root-fields-resolvers.
+	 *
+	 * If you return from `onSubscribe`, and the returned value is
+	 * missing the `rootValue` field, the relevant operation root
+	 * will be used instead.
+	 */
+	roots?: undefined | {
+		[operation in OperationTypeNode]?: Record<string, NonNullable<ExecutionArgs["rootValue"]>>;
+	};
+	/**
+	 * A custom GraphQL parse function allowing you to apply your own
+	 * parsing logic.
+	 *
+	 * Will not be used when implementing a custom `onSubscribe`.
+	 *
+	 * Throwing an error from within this function will close the socket
+	 * with the `Error` message in the close event reason.
+	 */
+	parse?: undefined | typeof parse;
+	/**
+	 * A custom GraphQL validate function allowing you to apply your
+	 * own validation rules.
+	 *
+	 * Returned, non-empty, array of `GraphQLError`s will be communicated
+	 * to the client through the `ErrorMessage`. Use an empty array if the
+	 * document is valid and no errors have been encountered.
+	 *
+	 * Will not be used when implementing a custom `onSubscribe`.
+	 *
+	 * Throwing an error from within this function will close the socket
+	 * with the `Error` message in the close event reason.
+	 */
+	validate?: undefined | typeof validate;
+	/**
+	 * Is the `execute` function from GraphQL which is
+	 * used to execute the query and mutation operations.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	execute?: undefined | ((args: ExecutionArgs) => OperationResult);
+	/**
+	 * Is the `subscribe` function from GraphQL which is
+	 * used to execute the subscription operation.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	subscribe?: undefined | ((args: ExecutionArgs) => OperationResult);
+	/**
+	 * The amount of time for which the server will wait
+	 * for `ConnectionInit` message.
+	 *
+	 * Set the value to `Infinity`, `''`, `0`, `null` or `undefined` to skip waiting.
+	 *
+	 * If the wait timeout has passed and the client
+	 * has not sent the `ConnectionInit` message,
+	 * the server will terminate the socket by
+	 * dispatching a close event `4408: Connection initialisation timeout`
+	 *
+	 * @default 3_000 // 3 seconds
+	 */
+	connectionInitWaitTimeout?: undefined | number;
+	/**
+	 * Is the connection callback called when the
+	 * client requests the connection initialisation
+	 * through the message `ConnectionInit`.
+	 *
+	 * The message payload (`connectionParams` from the
+	 * client) is present in the `Context.connectionParams`.
+	 *
+	 * - Returning `true` or nothing from the callback will
+	 * allow the client to connect.
+	 *
+	 * - Returning `false` from the callback will
+	 * terminate the socket by dispatching the
+	 * close event `4403: Forbidden`.
+	 *
+	 * - Returning a `Record` from the callback will
+	 * allow the client to connect and pass the returned
+	 * value to the client through the optional `payload`
+	 * field in the `ConnectionAck` message.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	onConnect?: undefined | ((ctx: Context<P, E>) => Promise<Record<string, unknown> | boolean | void> | Record<string, unknown> | boolean | void);
+	/**
+	 * Called when the client disconnects for whatever reason after
+	 * he successfully went through the connection initialisation phase.
+	 * Provides the close event too. Beware that this callback happens
+	 * AFTER all subscriptions have been gracefully completed and BEFORE
+	 * the `onClose` callback.
+	 *
+	 * If you are interested in tracking the subscriptions completions,
+	 * consider using the `onComplete` callback.
+	 *
+	 * This callback will be called EXCLUSIVELY if the client connection
+	 * is acknowledged. Meaning, `onConnect` will be called before the `onDisconnect`.
+	 *
+	 * For tracking socket closures at any point in time, regardless
+	 * of the connection state - consider using the `onClose` callback.
+	 */
+	onDisconnect?: undefined | ((ctx: Context<P, E>, code?: number, reason?: string) => Promise<void> | void);
+	/**
+	 * Called when the client sends a {@link MessageType.Ping} message, at any
+	 * point after the connection is opened - before or after the connection
+	 * initialisation phase.
+	 *
+	 * If the client sent the ping with a payload, it will be passed through the
+	 * second argument. The first argument provides the {@link Context} of the
+	 * connection.
+	 *
+	 * If this callback is implemented, the server will still automatically reply
+	 * to the ping with a pong, right after the callback resolves. Use the
+	 * low-level `onPing` listener on the websocket itself for full control over
+	 * the response - implementing that listener disables the automatic pong.
+	 */
+	onPing?: undefined | ((ctx: Context<P, E>, payload: PingMessage["payload"]) => Promise<void> | void);
+	/**
+	 * Called when the client sends a {@link MessageType.Pong} message, at any
+	 * point after the connection is opened - before or after the connection
+	 * initialisation phase.
+	 *
+	 * If the client sent the pong with a payload, it will be passed through the
+	 * second argument. The first argument provides the {@link Context} of the
+	 * connection.
+	 */
+	onPong?: undefined | ((ctx: Context<P, E>, payload: PongMessage["payload"]) => Promise<void> | void);
+	/**
+	 * Called when the socket closes for whatever reason, at any
+	 * point in time. Provides the close event too. Beware
+	 * that this callback happens AFTER all subscriptions have
+	 * been gracefully completed and AFTER the `onDisconnect` callback.
+	 *
+	 * If you are interested in tracking the subscriptions completions,
+	 * consider using the `onComplete` callback.
+	 *
+	 * In comparison to `onDisconnect`, this callback will ALWAYS
+	 * be called, regardless if the user successfully went through
+	 * the connection initialisation or not. `onConnect` might not
+	 * called before the `onClose`.
+	 */
+	onClose?: undefined | ((ctx: Context<P, E>, code?: number, reason?: string) => Promise<void> | void);
+	/**
+	 * The subscribe callback executed right after
+	 * acknowledging the request before any payload
+	 * processing has been performed.
+	 *
+	 * If you return `ExecutionArgs` from the callback,
+	 * it will be used instead of trying to build one
+	 * internally. In this case, you are responsible
+	 * for providing a ready set of arguments which will
+	 * be directly plugged in the operation execution.
+	 *
+	 * Omitting the fields `contextValue` or `rootValue`
+	 * from the returned value will have the provided server
+	 * options fill in the gaps.
+	 *
+	 * To report GraphQL errors simply return an array
+	 * of them from the callback, they will be reported
+	 * to the client through the error message.
+	 *
+	 * Useful for preparing the execution arguments
+	 * following a custom logic. A typical use case are
+	 * persisted queries, you can identify the query from
+	 * the subscribe message and create the GraphQL operation
+	 * execution args which are then returned by the function.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	onSubscribe?: undefined | ((ctx: Context<P, E>, id: string, payload: SubscribePayload) => Promise<ExecutionArgs | readonly GraphQLError[] | void> | ExecutionArgs | readonly GraphQLError[] | void);
+	/**
+	 * Executed after the operation call resolves. For streaming
+	 * operations, triggering this callback does not necessarily
+	 * mean that there is already a result available - it means
+	 * that the subscription process for the stream has resolved
+	 * and that the client is now subscribed.
+	 *
+	 * The `OperationResult` argument is the result of operation
+	 * execution. It can be an iterator or already a value.
+	 *
+	 * If you want the single result and the events from a streaming
+	 * operation, use the `onNext` callback.
+	 *
+	 * Use this callback to listen for subscribe operation and
+	 * execution result manipulation.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	onOperation?: undefined | ((ctx: Context<P, E>, id: string, payload: SubscribePayload, args: ExecutionArgs, result: OperationResult) => Promise<OperationResult | void> | OperationResult | void);
+	/**
+	 * Executed after an error occurred right before it
+	 * has been dispatched to the client.
+	 *
+	 * Use this callback to format the outgoing GraphQL
+	 * errors before they reach the client.
+	 *
+	 * Returned result will be injected in the error message payload.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	onError?: undefined | ((ctx: Context<P, E>, id: string, payload: SubscribePayload, errors: readonly GraphQLError[]) => Promise<readonly GraphQLFormattedError[] | void> | readonly GraphQLFormattedError[] | void);
+	/**
+	 * Executed after an operation has emitted a result right before
+	 * that result has been sent to the client. Results from both
+	 * single value and streaming operations will appear in this callback.
+	 *
+	 * Use this callback if you want to format the execution result
+	 * before it reaches the client.
+	 *
+	 * Returned result will be injected in the next message payload.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 */
+	onNext?: undefined | ((ctx: Context<P, E>, id: string, payload: SubscribePayload, args: ExecutionArgs, result: ExecutionResult$1) => Promise<FormattedExecutionResult | void> | FormattedExecutionResult | void);
+	/**
+	 * The complete callback is executed after the
+	 * operation has completed right before sending
+	 * the complete message to the client.
+	 *
+	 * Throwing an error from within this function will
+	 * close the socket with the `Error` message
+	 * in the close event reason.
+	 *
+	 * Since the library makes sure to complete streaming
+	 * operations even after an abrupt closure, this callback
+	 * will still be called.
+	 */
+	onComplete?: undefined | ((ctx: Context<P, E>, id: string, payload: SubscribePayload) => Promise<void> | void);
+	/**
+	 * An optional override for the JSON.parse function used to hydrate
+	 * incoming messages to this server. Useful for parsing custom datatypes
+	 * out of the incoming JSON.
+	 */
+	jsonMessageReviver?: undefined | JSONMessageReviver;
+	/**
+	 * An optional override for the JSON.stringify function used to serialize
+	 * outgoing messages to from server. Useful for serializing custom
+	 * datatypes out to the client.
+	 */
+	jsonMessageReplacer?: undefined | JSONMessageReplacer;
+}
+interface Server<E = undefined> {
+	/**
+	 * New socket has been established. The lib will validate
+	 * the protocol and use the socket accordingly. Returned promise
+	 * will resolve after the socket closes.
+	 *
+	 * The second argument will be passed in the `extra` field
+	 * of the `Context`. You may pass the initial request or the
+	 * original WebSocket, if you need it down the road.
+	 *
+	 * Returns a function that should be called when the same socket
+	 * has been closed, for whatever reason. The close code and reason
+	 * must be passed for reporting to the `onDisconnect` callback. Returned
+	 * promise will resolve once the internal cleanup is complete.
+	 */
+	opened(socket: WebSocket$1, ctxExtra: E): (code?: number, reason?: string) => Promise<void>;
+}
+interface WebSocket$1 {
+	/**
+	 * The subprotocol of the WebSocket. Will be used
+	 * to validate against the supported ones.
+	 */
+	readonly protocol: string;
+	/**
+	 * Sends a message through the socket. Will always
+	 * provide a `string` message.
+	 *
+	 * Please take care that the send is ready. Meaning,
+	 * only provide a truly OPEN socket through the `opened`
+	 * method of the `Server`.
+	 *
+	 * The returned promise is used to control the flow of data
+	 * (like handling backpressure).
+	 */
+	send(data: string): Promise<void> | void;
+	/**
+	 * Closes the socket gracefully. Will always provide
+	 * the appropriate code and close reason. `onDisconnect`
+	 * callback will be called.
+	 *
+	 * The returned promise is used to control the graceful
+	 * closure.
+	 */
+	close(code?: number, reason?: string): Promise<void> | void;
+	/**
+	 * Called when message is received. The library requires the data
+	 * to be a `string`.
+	 *
+	 * All operations requested from the client will block the promise until
+	 * completed, this means that the callback will not resolve until all
+	 * subscription events have been emitted (or until the client has completed
+	 * the stream), or until the query/mutation resolves.
+	 *
+	 * Exceptions raised during any phase of operation processing will
+	 * reject the callback's promise, catch them and communicate them
+	 * to your clients however you wish.
+	 */
+	onMessage(cb: (data: string) => Promise<void>): void;
+	/**
+	 * Implement a listener for the `PingMessage` sent from the client to the server.
+	 * If the client sent the ping with a payload, it will be passed through the
+	 * first argument.
+	 *
+	 * If this listener is implemented, the server will NOT automatically reply
+	 * to any pings from the client. Implementing it makes it your responsibility
+	 * to decide how and when to respond.
+	 */
+	onPing?(payload: PingMessage["payload"]): Promise<void> | void;
+	/**
+	 * Implement a listener for the `PongMessage` sent from the client to the server.
+	 * If the client sent the pong with a payload, it will be passed through the
+	 * first argument.
+	 */
+	onPong?(payload: PongMessage["payload"]): Promise<void> | void;
+}
+interface Context<P extends ConnectionInitMessage["payload"] = ConnectionInitMessage["payload"], E = unknown> {
+	/**
+	 * Indicates that the `ConnectionInit` message
+	 * has been received by the server. If this is
+	 * `true`, the client wont be kicked off after
+	 * the wait timeout has passed.
+	 */
+	readonly connectionInitReceived: boolean;
+	/**
+	 * Indicates that the connection was acknowledged
+	 * by having dispatched the `ConnectionAck` message
+	 * to the related client.
+	 */
+	readonly acknowledged: boolean;
+	/** The parameters passed during the connection initialisation. */
+	readonly connectionParams?: Readonly<P>;
+	/**
+	 * Holds the active subscriptions for this context. **All operations**
+	 * that are taking place are aggregated here. The user is _subscribed_
+	 * to an operation when waiting for result(s).
+	 *
+	 * If the subscription behind an ID is an `AsyncIterator` - the operation
+	 * is streaming; on the contrary, if the subscription is `null` - it is simply
+	 * a reservation, meaning - the operation resolves to a single result or is still
+	 * pending/being prepared.
+	 */
+	readonly subscriptions: Record<ID, AsyncGenerator<unknown> | AsyncIterable<unknown> | null>;
+	/**
+	 * An extra field where you can store your own context values
+	 * to pass between callbacks.
+	 */
+	extra: E;
+}
+/**
+ * Makes a Protocol compliant WebSocket GraphQL server. The server
+ * is actually an API which is to be used with your favourite WebSocket
+ * server library!
+ *
+ * Read more about the [GraphQL over WebSocket Protocol](https://github.com/graphql/graphql-over-http/blob/main/rfcs/GraphQLOverWebSocket.md).
+ *
+ * @category Server
+ */
+export declare function makeServer<P extends ConnectionInitMessage["payload"] = ConnectionInitMessage["payload"], E = unknown>(options: ServerOptions<P, E>): Server<E>;
+
+declare namespace Kind {
+	export { ARGUMENT, ARGUMENT_COORDINATE, BOOLEAN, DIRECTIVE, DIRECTIVE_ARGUMENT_COORDINATE, DIRECTIVE_COORDINATE, DIRECTIVE_DEFINITION, DIRECTIVE_EXTENSION, DOCUMENT, ENUM, ENUM_TYPE_DEFINITION, ENUM_TYPE_EXTENSION, ENUM_VALUE_DEFINITION, FIELD, FIELD_DEFINITION, FLOAT, FRAGMENT_ARGUMENT, FRAGMENT_DEFINITION, FRAGMENT_SPREAD, INLINE_FRAGMENT, INPUT_OBJECT_TYPE_DEFINITION, INPUT_OBJECT_TYPE_EXTENSION, INPUT_VALUE_DEFINITION, INT, INTERFACE_TYPE_DEFINITION, INTERFACE_TYPE_EXTENSION, LIST, LIST_TYPE, MEMBER_COORDINATE, NAME, NAMED_TYPE, NON_NULL_TYPE, NULL, OBJECT, OBJECT_FIELD, OBJECT_TYPE_DEFINITION, OBJECT_TYPE_EXTENSION, OPERATION_DEFINITION, OPERATION_TYPE_DEFINITION, SCALAR_TYPE_DEFINITION, SCALAR_TYPE_EXTENSION, SCHEMA_DEFINITION, SCHEMA_EXTENSION, SELECTION_SET, STRING, TYPE_COORDINATE, UNION_TYPE_DEFINITION, UNION_TYPE_EXTENSION, VARIABLE, VARIABLE_DEFINITION };
+}
+
+export {
+	Location$1 as Location,
+	Path as ResponsePath,
+	pathToArray as responsePathAsArray,
+};
+
+export {};