@power-plant/graphql-codegen 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,4677 @@
+import { Types } from "@graphql-codegen/plugin-helpers";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/jsutils/Maybe.d.ts
+/**
+ * Conveniently represents flow's "Maybe" type https://flow.org/en/docs/types/maybe/
+ *
+ * @internal
+ */
+type Maybe<T> = null | undefined | T;
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/jsutils/ObjMap.d.ts
+/** @internal */
+interface ObjMap<T> {
+  [key: string]: T;
+}
+/** @internal */
+interface ReadOnlyObjMap<T> {
+  readonly [key: string]: T;
+}
+declare namespace kinds__d_exports {
+  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 };
+}
+/** @category Kinds */
+/** AST kind for name nodes. */
+declare const NAME = "Name";
+/** Type of the `Kind.NAME` AST kind value. */
+type NAME = typeof NAME;
+/** AST kind for document nodes. */
+declare const DOCUMENT = "Document";
+/** Type of the `Kind.DOCUMENT` AST kind value. */
+type DOCUMENT = typeof DOCUMENT;
+/** AST kind for operation definition nodes. */
+declare const OPERATION_DEFINITION = "OperationDefinition";
+/** Type of the `Kind.OPERATION_DEFINITION` AST kind value. */
+type OPERATION_DEFINITION = typeof OPERATION_DEFINITION;
+/** AST kind for variable definition nodes. */
+declare const VARIABLE_DEFINITION = "VariableDefinition";
+/** Type of the `Kind.VARIABLE_DEFINITION` AST kind value. */
+type VARIABLE_DEFINITION = typeof VARIABLE_DEFINITION;
+/** AST kind for selection set nodes. */
+declare const SELECTION_SET = "SelectionSet";
+/** Type of the `Kind.SELECTION_SET` AST kind value. */
+type SELECTION_SET = typeof SELECTION_SET;
+/** AST kind for field selection nodes. */
+declare const FIELD = "Field";
+/** Type of the `Kind.FIELD` AST kind value. */
+type FIELD = typeof FIELD;
+/** AST kind for argument nodes. */
+declare const ARGUMENT = "Argument";
+/** Type of the `Kind.ARGUMENT` AST kind value. */
+type ARGUMENT = typeof ARGUMENT;
+/** AST kind for fragment argument nodes. */
+declare const FRAGMENT_ARGUMENT = "FragmentArgument";
+/** Type of the `Kind.FRAGMENT_ARGUMENT` AST kind value. */
+type FRAGMENT_ARGUMENT = typeof FRAGMENT_ARGUMENT;
+/** AST kind for fragment spread nodes. */
+declare const FRAGMENT_SPREAD = "FragmentSpread";
+/** Type of the `Kind.FRAGMENT_SPREAD` AST kind value. */
+type FRAGMENT_SPREAD = typeof FRAGMENT_SPREAD;
+/** AST kind for inline fragment nodes. */
+declare const INLINE_FRAGMENT = "InlineFragment";
+/** Type of the `Kind.INLINE_FRAGMENT` AST kind value. */
+type INLINE_FRAGMENT = typeof INLINE_FRAGMENT;
+/** AST kind for fragment definition nodes. */
+declare const FRAGMENT_DEFINITION = "FragmentDefinition";
+/** Type of the `Kind.FRAGMENT_DEFINITION` AST kind value. */
+type FRAGMENT_DEFINITION = typeof FRAGMENT_DEFINITION;
+/** AST kind for variable reference nodes. */
+declare const VARIABLE = "Variable";
+/** Type of the `Kind.VARIABLE` AST kind value. */
+type VARIABLE = typeof VARIABLE;
+/** AST kind for integer value nodes. */
+declare const INT = "IntValue";
+/** Type of the `Kind.INT` AST kind value. */
+type INT = typeof INT;
+/** AST kind for floating-point value nodes. */
+declare const FLOAT = "FloatValue";
+/** Type of the `Kind.FLOAT` AST kind value. */
+type FLOAT = typeof FLOAT;
+/** AST kind for string value nodes. */
+declare const STRING = "StringValue";
+/** Type of the `Kind.STRING` AST kind value. */
+type STRING = typeof STRING;
+/** AST kind for boolean value nodes. */
+declare const BOOLEAN = "BooleanValue";
+/** Type of the `Kind.BOOLEAN` AST kind value. */
+type BOOLEAN = typeof BOOLEAN;
+/** AST kind for null value nodes. */
+declare const NULL = "NullValue";
+/** Type of the `Kind.NULL` AST kind value. */
+type NULL = typeof NULL;
+/** AST kind for enum value nodes. */
+declare const ENUM = "EnumValue";
+/** Type of the `Kind.ENUM` AST kind value. */
+type ENUM = typeof ENUM;
+/** AST kind for list value nodes. */
+declare const LIST = "ListValue";
+/** Type of the `Kind.LIST` AST kind value. */
+type LIST = typeof LIST;
+/** AST kind for object value nodes. */
+declare const OBJECT = "ObjectValue";
+/** Type of the `Kind.OBJECT` AST kind value. */
+type OBJECT = typeof OBJECT;
+/** AST kind for object field nodes. */
+declare const OBJECT_FIELD = "ObjectField";
+/** Type of the `Kind.OBJECT_FIELD` AST kind value. */
+type OBJECT_FIELD = typeof OBJECT_FIELD;
+/** AST kind for directive nodes. */
+declare const DIRECTIVE = "Directive";
+/** Type of the `Kind.DIRECTIVE` AST kind value. */
+type DIRECTIVE = typeof DIRECTIVE;
+/** AST kind for named type reference nodes. */
+declare const NAMED_TYPE = "NamedType";
+/** Type of the `Kind.NAMED_TYPE` AST kind value. */
+type NAMED_TYPE = typeof NAMED_TYPE;
+/** AST kind for list type reference nodes. */
+declare const LIST_TYPE = "ListType";
+/** Type of the `Kind.LIST_TYPE` AST kind value. */
+type LIST_TYPE = typeof LIST_TYPE;
+/** AST kind for non-null type reference nodes. */
+declare const NON_NULL_TYPE = "NonNullType";
+/** Type of the `Kind.NON_NULL_TYPE` AST kind value. */
+type NON_NULL_TYPE = typeof NON_NULL_TYPE;
+/** AST kind for schema definition nodes. */
+declare const SCHEMA_DEFINITION = "SchemaDefinition";
+/** Type of the `Kind.SCHEMA_DEFINITION` AST kind value. */
+type SCHEMA_DEFINITION = typeof SCHEMA_DEFINITION;
+/** AST kind for operation type definition nodes. */
+declare const OPERATION_TYPE_DEFINITION = "OperationTypeDefinition";
+/** Type of the `Kind.OPERATION_TYPE_DEFINITION` AST kind value. */
+type OPERATION_TYPE_DEFINITION = typeof OPERATION_TYPE_DEFINITION;
+/** AST kind for scalar type definition nodes. */
+declare const SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition";
+/** Type of the `Kind.SCALAR_TYPE_DEFINITION` AST kind value. */
+type SCALAR_TYPE_DEFINITION = typeof SCALAR_TYPE_DEFINITION;
+/** AST kind for object type definition nodes. */
+declare const OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition";
+/** Type of the `Kind.OBJECT_TYPE_DEFINITION` AST kind value. */
+type OBJECT_TYPE_DEFINITION = typeof OBJECT_TYPE_DEFINITION;
+/** AST kind for field definition nodes. */
+declare const FIELD_DEFINITION = "FieldDefinition";
+/** Type of the `Kind.FIELD_DEFINITION` AST kind value. */
+type FIELD_DEFINITION = typeof FIELD_DEFINITION;
+/** AST kind for input value definition nodes. */
+declare const INPUT_VALUE_DEFINITION = "InputValueDefinition";
+/** Type of the `Kind.INPUT_VALUE_DEFINITION` AST kind value. */
+type INPUT_VALUE_DEFINITION = typeof INPUT_VALUE_DEFINITION;
+/** AST kind for interface type definition nodes. */
+declare const INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition";
+/** Type of the `Kind.INTERFACE_TYPE_DEFINITION` AST kind value. */
+type INTERFACE_TYPE_DEFINITION = typeof INTERFACE_TYPE_DEFINITION;
+/** AST kind for union type definition nodes. */
+declare const UNION_TYPE_DEFINITION = "UnionTypeDefinition";
+/** Type of the `Kind.UNION_TYPE_DEFINITION` AST kind value. */
+type UNION_TYPE_DEFINITION = typeof UNION_TYPE_DEFINITION;
+/** AST kind for enum type definition nodes. */
+declare const ENUM_TYPE_DEFINITION = "EnumTypeDefinition";
+/** AST kind for enum value definition nodes. */
+declare const ENUM_VALUE_DEFINITION = "EnumValueDefinition";
+/** Type of the `Kind.ENUM_VALUE_DEFINITION` AST kind value. */
+type ENUM_VALUE_DEFINITION = typeof ENUM_VALUE_DEFINITION;
+/** AST kind for input object type definition nodes. */
+declare const INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition";
+/** Type of the `Kind.INPUT_OBJECT_TYPE_DEFINITION` AST kind value. */
+type INPUT_OBJECT_TYPE_DEFINITION = typeof INPUT_OBJECT_TYPE_DEFINITION;
+/** AST kind for directive definition nodes. */
+declare const DIRECTIVE_DEFINITION = "DirectiveDefinition";
+/** Type of the `Kind.DIRECTIVE_DEFINITION` AST kind value. */
+type DIRECTIVE_DEFINITION = typeof DIRECTIVE_DEFINITION;
+/** AST kind for schema extension nodes. */
+declare const SCHEMA_EXTENSION = "SchemaExtension";
+/** Type of the `Kind.SCHEMA_EXTENSION` AST kind value. */
+type SCHEMA_EXTENSION = typeof SCHEMA_EXTENSION;
+/** AST kind for directive extension nodes. */
+declare const DIRECTIVE_EXTENSION = "DirectiveExtension";
+/** Type of the `Kind.DIRECTIVE_EXTENSION` AST kind value. */
+type DIRECTIVE_EXTENSION = typeof DIRECTIVE_EXTENSION;
+/** AST kind for scalar type extension nodes. */
+declare const SCALAR_TYPE_EXTENSION = "ScalarTypeExtension";
+/** Type of the `Kind.SCALAR_TYPE_EXTENSION` AST kind value. */
+type SCALAR_TYPE_EXTENSION = typeof SCALAR_TYPE_EXTENSION;
+/** AST kind for object type extension nodes. */
+declare const OBJECT_TYPE_EXTENSION = "ObjectTypeExtension";
+/** Type of the `Kind.OBJECT_TYPE_EXTENSION` AST kind value. */
+type OBJECT_TYPE_EXTENSION = typeof OBJECT_TYPE_EXTENSION;
+/** AST kind for interface type extension nodes. */
+declare const INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension";
+/** Type of the `Kind.INTERFACE_TYPE_EXTENSION` AST kind value. */
+type INTERFACE_TYPE_EXTENSION = typeof INTERFACE_TYPE_EXTENSION;
+/** AST kind for union type extension nodes. */
+declare const UNION_TYPE_EXTENSION = "UnionTypeExtension";
+/** Type of the `Kind.UNION_TYPE_EXTENSION` AST kind value. */
+type UNION_TYPE_EXTENSION = typeof UNION_TYPE_EXTENSION;
+/** AST kind for enum type extension nodes. */
+declare const ENUM_TYPE_EXTENSION = "EnumTypeExtension";
+/** Type of the `Kind.ENUM_TYPE_EXTENSION` AST kind value. */
+type ENUM_TYPE_EXTENSION = typeof ENUM_TYPE_EXTENSION;
+/** AST kind for input object type extension nodes. */
+declare const INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
+/** Type of the `Kind.INPUT_OBJECT_TYPE_EXTENSION` AST kind value. */
+type INPUT_OBJECT_TYPE_EXTENSION = typeof INPUT_OBJECT_TYPE_EXTENSION;
+/** AST kind for type coordinate nodes. */
+declare const TYPE_COORDINATE = "TypeCoordinate";
+/** Type of the `Kind.TYPE_COORDINATE` AST kind value. */
+type TYPE_COORDINATE = typeof TYPE_COORDINATE;
+/** AST kind for member coordinate nodes. */
+declare const MEMBER_COORDINATE = "MemberCoordinate";
+/** Type of the `Kind.MEMBER_COORDINATE` AST kind value. */
+type MEMBER_COORDINATE = typeof MEMBER_COORDINATE;
+/** AST kind for argument coordinate nodes. */
+declare const ARGUMENT_COORDINATE = "ArgumentCoordinate";
+/** Type of the `Kind.ARGUMENT_COORDINATE` AST kind value. */
+type ARGUMENT_COORDINATE = typeof ARGUMENT_COORDINATE;
+/** AST kind for directive coordinate nodes. */
+declare const DIRECTIVE_COORDINATE = "DirectiveCoordinate";
+/** Type of the `Kind.DIRECTIVE_COORDINATE` AST kind value. */
+type DIRECTIVE_COORDINATE = typeof DIRECTIVE_COORDINATE;
+/** AST kind for directive argument coordinate nodes. */
+declare const DIRECTIVE_ARGUMENT_COORDINATE = "DirectiveArgumentCoordinate";
+/** Type of the `Kind.DIRECTIVE_ARGUMENT_COORDINATE` AST kind value. */
+type DIRECTIVE_ARGUMENT_COORDINATE = typeof DIRECTIVE_ARGUMENT_COORDINATE;
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/language/KindTypeMap.d.ts
+/** @internal */
+type KindTypeMap = typeof kinds__d_exports;
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/language/source.d.ts
+/** @category Source */
+interface Location$1 {
+  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.
+ */
+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$1;
+  /**
+   * 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$1);
+  /**
+   * Returns the value used by `Object.prototype.toString`.
+   * @returns The built-in string tag for this object.
+   */
+  get [Symbol.toStringTag](): string;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/language/tokenKind.d.ts
+/** @category Lexing */
+/**
+ * An exported enum describing the different kinds of tokens that the
+ * lexer emits.
+ */
+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.
+ */
+type TokenKind = (typeof TokenKind)[keyof typeof TokenKind];
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/language/ast.d.ts
+/**
+ * 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 {
+  /** 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.
+ */
+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;
+  };
+}
+/** An identifier in a GraphQL document. */
+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 | undefined;
+  /** Parsed value represented by this node. */
+  readonly value: string;
+}
+/** A query, mutation, or subscription operation definition. */
+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 | 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;
+}
+/**
+ * The operation types supported by GraphQL executable definitions.
+ * @category Kinds
+ */
+declare const OperationTypeNode: {
+  readonly QUERY: "query";
+  readonly MUTATION: "mutation";
+  readonly SUBSCRIPTION: "subscription";
+};
+/**
+ * The operation types supported by GraphQL executable definitions.
+ * @category Kinds
+ */
+type OperationTypeNode = (typeof OperationTypeNode)[keyof typeof OperationTypeNode];
+/** A variable declaration in an operation or experimental fragment definition. */
+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 | 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`. */
+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 | undefined;
+  /** Name node identifying this AST node. */
+  readonly name: NameNode;
+}
+/** A set of fields and fragments selected from an object, interface, or union. */
+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 | undefined;
+  /** Fields and fragments contained in this selection set. */
+  selections: ReadonlyArray<SelectionNode>;
+}
+/** Any selection that may appear inside a selection set. */
+type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
+/** A field selected in an executable GraphQL document. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+interface FragmentArgumentNode {
+  /** AST node kind for a fragment argument. */
+  readonly kind: KindTypeMap['FRAGMENT_ARGUMENT'];
+  /** Source location for this fragment argument. */
+  readonly loc?: Location | 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`. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
+/** Any value literal that is guaranteed not to contain a variable reference. */
+type ConstValueNode = IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode;
+/** An integer value literal. */
+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 | undefined;
+  /** Parsed value represented by this node. */
+  readonly value: string;
+}
+/** A floating-point value literal. */
+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 | undefined;
+  /** Parsed value represented by this node. */
+  readonly value: string;
+}
+/** A string value literal. */
+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 | 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. */
+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 | undefined;
+  /** Parsed value represented by this node. */
+  readonly value: boolean;
+}
+/** A null value literal. */
+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 | undefined;
+}
+/** An enum value literal. */
+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 | undefined;
+  /** Parsed value represented by this node. */
+  readonly value: string;
+}
+/** A list value literal. */
+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 | 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. */
+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 | undefined;
+  /** Values contained in this enum, list, or input-object definition. */
+  readonly values: ReadonlyArray<ConstValueNode>;
+}
+/** An input object value literal. */
+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 | 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. */
+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 | undefined;
+  /** Fields declared by this object, interface, input object, or literal. */
+  readonly fields: ReadonlyArray<ConstObjectFieldNode>;
+}
+/** A field inside an input object value literal. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
+/** A named type reference. */
+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 | undefined;
+  /** Name node identifying this AST node. */
+  readonly name: NameNode;
+}
+/** A list type reference. */
+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 | undefined;
+  /** The GraphQL type reference or runtime type for this element. */
+  readonly type: TypeNode;
+}
+/** A non-null type reference. */
+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 | undefined;
+  /** The GraphQL type reference or runtime type for this element. */
+  readonly type: NamedTypeNode | ListTypeNode;
+}
+/** A schema definition in a type-system document. */
+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 | 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. */
+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 | undefined;
+  /** The operation selected for execution. */
+  readonly operation: OperationTypeNode;
+  /** The GraphQL type reference or runtime type for this element. */
+  readonly type: NamedTypeNode;
+}
+/** A scalar type definition in a type-system document. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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>;
+}
+/** A schema extension in a type-system document. */
+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 | 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;
+}
+/** A scalar type extension. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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. */
+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 | 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;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/jsutils/Path.d.ts
+/** 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;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/jsutils/PromiseOrValue.d.ts
+/** @internal */
+type PromiseOrValue<T> = Promise<T> | T;
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/language/directiveLocation.d.ts
+/** @category Kinds */
+/** The set of allowed directive location values. */
+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. */
+type DirectiveLocation = (typeof DirectiveLocation)[keyof typeof DirectiveLocation];
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/type/directives.d.ts
+/**
+ * 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.
+ */
+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.
+ */
+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. */
+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>>;
+}
+/** @internal */
+interface GraphQLDirectiveNormalizedConfig extends GraphQLDirectiveConfig {
+  args: GraphQLFieldNormalizedConfigArgumentMap;
+  isRepeatable: boolean;
+  extensions: Readonly<GraphQLDirectiveExtensions>;
+  extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/execution/getVariableSignature.d.ts
+/**
+ * A GraphQLVariableSignature is required to coerce a variable value.
+ *
+ * Designed to have comparable interface to GraphQLArgument so that
+ * getArgumentValues() can be reused for fragment arguments.
+ *
+ * @internal
+ */
+interface GraphQLVariableSignature {
+  name: string;
+  type: GraphQLInputType;
+  defaultValue?: never;
+  default: {
+    literal: ConstValueNode;
+  } | undefined;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/execution/values.d.ts
+/**
+ * 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.
+ */
+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;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/type/definition.d.ts
+/** These are all of the possible kinds of types. */
+type GraphQLType = GraphQLNamedType | GraphQLWrappingType;
+/** These types may be used as input types for arguments and directives. */
+type GraphQLNullableInputType = GraphQLNamedInputType | GraphQLList<GraphQLInputType>;
+/** These types may be used as input types for arguments and directives. */
+type GraphQLInputType = GraphQLNullableInputType | GraphQLNonNull<GraphQLNullableInputType>;
+/** These types may be used as output types as the result of fields. */
+type GraphQLNullableOutputType = GraphQLNamedOutputType | GraphQLList<GraphQLOutputType>;
+/** These types may be used as output types as the result of fields. */
+type GraphQLOutputType = GraphQLNullableOutputType | GraphQLNonNull<GraphQLNullableOutputType>;
+/** These types may describe the parent context of a selection set. */
+type GraphQLCompositeType = GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType;
+/** These types may describe the parent context of a selection set. */
+type GraphQLAbstractType = GraphQLInterfaceType | GraphQLUnionType;
+/**
+ * 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) },
+ *   }),
+ * });
+ * ```
+ */
+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.
+ */
+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 */
+type GraphQLWrappingType = GraphQLList<GraphQLType> | GraphQLNonNull<GraphQLNullableType>;
+/** These types can all accept null as a value. */
+type GraphQLNullableType = GraphQLNamedType | GraphQLList<GraphQLType>;
+/** These named types do not include modifiers like List or NonNull. */
+type GraphQLNamedType = GraphQLNamedInputType | GraphQLNamedOutputType;
+/** A named GraphQL type that can be used as an input type. */
+type GraphQLNamedInputType = GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType;
+/** A named GraphQL type that can be used as an output type. */
+type GraphQLNamedOutputType = GraphQLScalarType | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | GraphQLEnumType;
+/**
+ * An interface for all Schema Elements.
+ *
+ * @internal
+ */
+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.
+ */
+type ThunkReadonlyArray<T> = (() => ReadonlyArray<T>) | ReadonlyArray<T>;
+/**
+ * A thunk that resolves to an object map.
+ * @typeParam T - Value type stored in the object map.
+ */
+type ThunkObjMap<T> = (() => ObjMap<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.
+ */
+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)) };
+ *   },
+ * });
+ * ```
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+type GraphQLScalarValueParser<TInternal> = (inputValue: unknown) => TInternal;
+/**
+ * Function used to coerce externally provided scalar input values.
+ * @typeParam TInternal - Internal runtime representation for this scalar.
+ */
+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.
+ */
+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.
+ */
+type GraphQLScalarInputLiteralCoercer<TInternal> = (valueNode: ConstValueNode) => Maybe<TInternal>;
+/** @internal */
+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.
+ */
+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>>;
+}
+/** @internal */
+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.
+ */
+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 },
+ *   }),
+ * });
+ * ```
+ */
+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.
+ */
+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>>;
+}
+/** @internal */
+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.
+ */
+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.
+ */
+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.
+ */
+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. */
+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. */
+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.
+ */
+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.
+ */
+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>;
+}
+/** @internal */
+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. */
+type GraphQLFieldConfigArgumentMap = ObjMap<GraphQLArgumentConfig>;
+/** @internal */
+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.
+ */
+interface GraphQLArgumentExtensions {
+  [attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL argument. */
+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>;
+}
+/** @internal */
+interface GraphQLArgumentNormalizedConfig extends GraphQLArgumentConfig {
+  default: GraphQLDefaultInput | undefined;
+  extensions: Readonly<GraphQLArgumentExtensions>;
+}
+/** @internal */
+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.
+ */
+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. */
+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;
+}
+/**
+ * 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.
+ */
+type GraphQLFieldMap<TSource, TContext> = ObjMap<GraphQLField<TSource, TContext>>;
+/** Default input represented as either a runtime value or a GraphQL literal. */
+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.
+ */
+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 },
+ *   },
+ * });
+ * ```
+ */
+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.
+ */
+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>>;
+}
+/** @internal */
+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.
+ */
+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;
+ *     }
+ *   },
+ * });
+ * ```
+ */
+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.
+ */
+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>>;
+}
+/** @internal */
+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.
+ */
+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.
+ */
+declare class GraphQLEnumType 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. */
+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>>;
+}
+/** @internal */
+interface GraphQLEnumTypeNormalizedConfig extends GraphQLEnumTypeConfig {
+  values: GraphQLEnumValueNormalizedConfigMap;
+  extensions: Readonly<GraphQLEnumTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
+}
+/** @internal */
+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.
+ */
+interface GraphQLEnumValueExtensions {
+  [attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL enum value. */
+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>;
+}
+/** @internal */
+interface GraphQLEnumValueNormalizedConfig extends GraphQLEnumValueConfig {
+  extensions: Readonly<GraphQLEnumValueExtensions>;
+}
+/** A resolved GraphQL enum value definition. */
+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.
+ */
+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 } },
+ *   },
+ * });
+ * ```
+ */
+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. */
+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;
+}
+/** @internal */
+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.
+ */
+interface GraphQLInputFieldExtensions {
+  [attributeName: string | symbol]: unknown;
+}
+/** Configuration used to define a GraphQL input field. */
+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>;
+}
+/** @internal */
+interface GraphQLInputFieldNormalizedConfig extends GraphQLInputFieldConfig {
+  default: GraphQLDefaultInput | undefined;
+  extensions: Readonly<GraphQLInputFieldExtensions>;
+}
+/** @internal */
+type GraphQLInputFieldNormalizedConfigMap = ObjMap<GraphQLInputFieldNormalizedConfig>;
+/** A resolved GraphQL input field definition. */
+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;
+}
+/** A map of input field names to resolved input field definitions. */
+type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;
+//#endregion
+//#region ../../../node_modules/.pnpm/graphql@17.0.2/node_modules/graphql/type/schema.d.ts
+/**
+ * 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.
+ */
+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]),
+ * });
+ * ```
+ */
+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>;
+/** @internal */
+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. */
+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>>;
+}
+/** @internal */
+interface GraphQLSchemaNormalizedConfig extends GraphQLSchemaConfig {
+  description: Maybe<string>;
+  types: ReadonlyArray<GraphQLNamedType>;
+  directives: ReadonlyArray<GraphQLDirective>;
+  extensions: Readonly<GraphQLSchemaExtensions>;
+  extensionASTNodes: ReadonlyArray<SchemaExtensionNode>;
+  assumeValid: boolean;
+}
+//#endregion
+//#region src/index.d.ts
+type Options = Types.GenerateOptions;
+declare const _default: import("@power-plant/core").GeneratorConfigObject<GraphQLSchema, Types.GenerateOptions, void>;
+//#endregion
+export { Options, _default as default };
+//# sourceMappingURL=index.d.mts.map