@graphql-tools/utils

  • Version 8.9.0
  • Published
  • 416 kB
  • 1 dependency
  • MIT license

Install

npm i @graphql-tools/utils
yarn add @graphql-tools/utils
pnpm add @graphql-tools/utils

Overview

Common package containing utils and types for GraphQL tools

Index

Variables

Functions

Interfaces

Enums

Type Aliases

Variables

variable AggregateError

let AggregateError: AggregateErrorConstructor;

    Functions

    function addTypes

    addTypes: (
    schema: GraphQLSchema,
    newTypesOrDirectives: Array<GraphQLNamedType | GraphQLDirective>
    ) => GraphQLSchema;

      function appendObjectFields

      appendObjectFields: (
      schema: GraphQLSchema,
      typeName: string,
      additionalFields: GraphQLFieldConfigMap<any, any>
      ) => GraphQLSchema;

        function asArray

        asArray: <T>(fns: T | T[]) => T[];

          function assertSome

          assertSome: <T>(input: T, message?: string) => asserts input is Exclude<T, null>;

            function astFromArg

            astFromArg: (
            arg: GraphQLArgument,
            schema?: GraphQLSchema,
            pathToDirectivesInExtensions?: Array<string>
            ) => InputValueDefinitionNode;

              function astFromDirective

              astFromDirective: (
              directive: GraphQLDirective,
              schema?: GraphQLSchema,
              pathToDirectivesInExtensions?: Array<string>
              ) => DirectiveDefinitionNode;

                function astFromEnumType

                astFromEnumType: (
                type: GraphQLEnumType,
                schema: GraphQLSchema,
                pathToDirectivesInExtensions?: Array<string>
                ) => EnumTypeDefinitionNode;

                  function astFromEnumValue

                  astFromEnumValue: (
                  value: GraphQLEnumValue,
                  schema: GraphQLSchema,
                  pathToDirectivesInExtensions?: Array<string>
                  ) => EnumValueDefinitionNode;

                    function astFromField

                    astFromField: (
                    field: GraphQLField<any, any>,
                    schema: GraphQLSchema,
                    pathToDirectivesInExtensions?: Array<string>
                    ) => FieldDefinitionNode;

                      function astFromInputField

                      astFromInputField: (
                      field: GraphQLInputField,
                      schema: GraphQLSchema,
                      pathToDirectivesInExtensions?: Array<string>
                      ) => InputValueDefinitionNode;

                        function astFromInputObjectType

                        astFromInputObjectType: (
                        type: GraphQLInputObjectType,
                        schema: GraphQLSchema,
                        pathToDirectivesInExtensions?: Array<string>
                        ) => InputObjectTypeDefinitionNode;

                          function astFromInterfaceType

                          astFromInterfaceType: (
                          type: GraphQLInterfaceType,
                          schema: GraphQLSchema,
                          pathToDirectivesInExtensions?: Array<string>
                          ) => InterfaceTypeDefinitionNode;

                            function astFromObjectType

                            astFromObjectType: (
                            type: GraphQLObjectType,
                            schema: GraphQLSchema,
                            pathToDirectivesInExtensions?: Array<string>
                            ) => ObjectTypeDefinitionNode;

                              function astFromScalarType

                              astFromScalarType: (
                              type: GraphQLScalarType,
                              schema: GraphQLSchema,
                              pathToDirectivesInExtensions?: Array<string>
                              ) => ScalarTypeDefinitionNode;

                                function astFromSchema

                                astFromSchema: (
                                schema: GraphQLSchema,
                                pathToDirectivesInExtensions?: Array<string>
                                ) => SchemaDefinitionNode | SchemaExtensionNode | null;

                                  function astFromUnionType

                                  astFromUnionType: (
                                  type: GraphQLUnionType,
                                  schema: GraphQLSchema,
                                  pathToDirectivesInExtensions?: Array<string>
                                  ) => UnionTypeDefinitionNode;

                                    function astFromValueUntyped

                                    astFromValueUntyped: (value: any) => ValueNode | null;
                                    • Produces a GraphQL Value AST given a JavaScript object. Function will match JavaScript/JSON values to GraphQL AST schema format by using the following mapping.

                                      | JSON Value | GraphQL Value | | ------------- | -------------------- | | Object | Input Object | | Array | List | | Boolean | Boolean | | String | String | | Number | Int / Float | | null | NullValue |

                                    function buildOperationNodeForField

                                    buildOperationNodeForField: ({
                                    schema,
                                    kind,
                                    field,
                                    models,
                                    ignore,
                                    depthLimit,
                                    circularReferenceDepth,
                                    argNames,
                                    selectedFields,
                                    }: {
                                    schema: GraphQLSchema;
                                    kind: OperationTypeNode;
                                    field: string;
                                    models?: string[];
                                    ignore?: Ignore;
                                    depthLimit?: number;
                                    circularReferenceDepth?: number;
                                    argNames?: string[];
                                    selectedFields?: SelectedFields;
                                    }) => OperationDefinitionNode;

                                      function checkValidationErrors

                                      checkValidationErrors: (
                                      loadDocumentErrors: ReadonlyArray<LoadDocumentError>
                                      ) => void | never;

                                        function collectComment

                                        collectComment: (node: NamedDefinitionNode) => void;

                                          function collectFields

                                          collectFields: (
                                          schema: GraphQLSchema,
                                          fragments: Record<string, FragmentDefinitionNode>,
                                          variableValues: { [variable: string]: unknown },
                                          runtimeType: GraphQLObjectType,
                                          selectionSet: SelectionSetNode,
                                          fields: Map<string, Array<FieldNode>>,
                                          visitedFragmentNames: Set<string>
                                          ) => Map<string, Array<FieldNode>>;

                                            function collectSubFields

                                            collectSubFields: (
                                            schema: GraphQLSchema,
                                            fragments: Record<string, FragmentDefinitionNode>,
                                            variableValues: Record<string, any>,
                                            type: GraphQLObjectType,
                                            fieldNodes: Array<FieldNode>
                                            ) => Map<string, Array<FieldNode>>;

                                              function compareNodes

                                              compareNodes: (
                                              a: ASTNode,
                                              b: ASTNode,
                                              customFn?: (a: any, b: any) => number
                                              ) => number;

                                                function compareStrings

                                                compareStrings: <A, B>(a: A, b: B) => 1 | -1 | 0;

                                                  function correctASTNodes

                                                  correctASTNodes: {
                                                  (type: GraphQLObjectType): GraphQLObjectType;
                                                  (type: GraphQLInterfaceType): GraphQLInterfaceType;
                                                  (type: GraphQLInputObjectType): GraphQLInputObjectType;
                                                  (type: GraphQLEnumType): GraphQLEnumType;
                                                  };

                                                    function createDefaultRules

                                                    createDefaultRules: () => import('graphql').ValidationRule[];

                                                      function createGraphQLError

                                                      createGraphQLError: (
                                                      message: string,
                                                      options?: GraphQLErrorOptions
                                                      ) => GraphQLError;

                                                        function createNamedStub

                                                        createNamedStub: {
                                                        (name: string, type: 'object'): GraphQLObjectType;
                                                        (name: string, type: 'interface'): GraphQLInterfaceType;
                                                        (name: string, type: 'input'): GraphQLInputObjectType;
                                                        };

                                                          function createStub

                                                          createStub: {
                                                          (node: TypeNode, type: 'output'): GraphQLOutputType;
                                                          (node: TypeNode, type: 'input'): GraphQLInputType;
                                                          (node: TypeNode, type: 'input' | 'output'): GraphQLType;
                                                          };

                                                            function createVariableNameGenerator

                                                            createVariableNameGenerator: (
                                                            variableDefinitionMap: Record<string, VariableDefinitionNode>
                                                            ) => (argName: string) => string;

                                                              function dedentBlockStringValue

                                                              dedentBlockStringValue: (rawString: string) => string;

                                                                function filterSchema

                                                                filterSchema: ({
                                                                schema,
                                                                typeFilter,
                                                                fieldFilter,
                                                                rootFieldFilter,
                                                                objectFieldFilter,
                                                                interfaceFieldFilter,
                                                                inputObjectFieldFilter,
                                                                argumentFilter,
                                                                }: {
                                                                schema: GraphQLSchema;
                                                                rootFieldFilter?: RootFieldFilter;
                                                                typeFilter?: TypeFilter;
                                                                fieldFilter?: FieldFilter;
                                                                objectFieldFilter?: FieldFilter;
                                                                interfaceFieldFilter?: FieldFilter;
                                                                inputObjectFieldFilter?: FieldFilter;
                                                                argumentFilter?: ArgumentFilter;
                                                                }) => GraphQLSchema;

                                                                  function fixSchemaAst

                                                                  fixSchemaAst: (
                                                                  schema: GraphQLSchema,
                                                                  options: BuildSchemaOptions & SchemaPrintOptions
                                                                  ) => GraphQLSchema;

                                                                    function forEachDefaultValue

                                                                    forEachDefaultValue: (
                                                                    schema: GraphQLSchema,
                                                                    fn: IDefaultValueIteratorFn
                                                                    ) => void;

                                                                      function forEachField

                                                                      forEachField: (schema: GraphQLSchema, fn: IFieldIteratorFn) => void;

                                                                        function getArgumentValues

                                                                        getArgumentValues: (
                                                                        def: GraphQLField<any, any> | GraphQLDirective,
                                                                        node: FieldNode | DirectiveNode,
                                                                        variableValues?: Record<string, any>
                                                                        ) => Record<string, any>;
                                                                        • Prepares an object map of argument values given a list of argument definitions and list of argument AST nodes.

                                                                          Note: The returned value is a plain Object with a prototype, since it is exposed to user code. Care should be taken to not pull values from the Object prototype.

                                                                        function getAsyncIterableWithCancel

                                                                        getAsyncIterableWithCancel: <
                                                                        T,
                                                                        TAsyncIterable extends AsyncIterable<T>,
                                                                        TReturn = any
                                                                        >(
                                                                        asyncIterable: TAsyncIterable,
                                                                        onCancel: (value?: TReturn) => void | Promise<void>
                                                                        ) => TAsyncIterable;

                                                                          function getAsyncIteratorWithCancel

                                                                          getAsyncIteratorWithCancel: <T, TReturn = any>(
                                                                          asyncIterator: AsyncIterator<T>,
                                                                          onCancel: (value?: TReturn) => void | Promise<void>
                                                                          ) => AsyncIterator<T>;

                                                                            function getBuiltInForStub

                                                                            getBuiltInForStub: (type: GraphQLNamedType) => GraphQLNamedType;

                                                                              function getComment

                                                                              getComment: (node: { loc?: Location }) => undefined | string;

                                                                                function getDefinedRootType

                                                                                getDefinedRootType: (
                                                                                schema: GraphQLSchema,
                                                                                operation: OperationTypeNode
                                                                                ) => GraphQLObjectType;

                                                                                  function getDeprecatableDirectiveNodes

                                                                                  getDeprecatableDirectiveNodes: (
                                                                                  entity:
                                                                                  | GraphQLArgument
                                                                                  | GraphQLField<any, any>
                                                                                  | GraphQLInputField
                                                                                  | GraphQLEnumValue,
                                                                                  schema?: GraphQLSchema,
                                                                                  pathToDirectivesInExtensions?: Array<string>
                                                                                  ) => Array<DirectiveNode>;

                                                                                    function getDescription

                                                                                    getDescription: (
                                                                                    node: { description?: StringValueNode; loc?: Location },
                                                                                    options?: { commentDescriptions?: boolean }
                                                                                    ) => string | undefined;

                                                                                      function getDirective

                                                                                      getDirective: (
                                                                                      schema: GraphQLSchema,
                                                                                      node: DirectableGraphQLObject,
                                                                                      directiveName: string,
                                                                                      pathToDirectivesInExtensions?: string[]
                                                                                      ) => Array<Record<string, any>> | undefined;

                                                                                        function getDirectiveInExtensions

                                                                                        getDirectiveInExtensions: (
                                                                                        node: DirectableGraphQLObject,
                                                                                        directiveName: string,
                                                                                        pathToDirectivesInExtensions?: string[]
                                                                                        ) => Array<Record<string, any>> | undefined;

                                                                                          function getDirectiveNodes

                                                                                          getDirectiveNodes: (
                                                                                          entity: GraphQLSchema | GraphQLNamedType | GraphQLEnumValue,
                                                                                          schema: GraphQLSchema,
                                                                                          pathToDirectivesInExtensions?: Array<string>
                                                                                          ) => Array<DirectiveNode>;

                                                                                            function getDirectives

                                                                                            getDirectives: (
                                                                                            schema: GraphQLSchema,
                                                                                            node: DirectableGraphQLObject,
                                                                                            pathToDirectivesInExtensions?: string[]
                                                                                            ) => Array<DirectiveAnnotation>;

                                                                                              function getDirectivesInExtensions

                                                                                              getDirectivesInExtensions: (
                                                                                              node: DirectableGraphQLObject,
                                                                                              pathToDirectivesInExtensions?: string[]
                                                                                              ) => Array<DirectiveAnnotation>;

                                                                                                function getDocumentNodeFromSchema

                                                                                                getDocumentNodeFromSchema: (
                                                                                                schema: GraphQLSchema,
                                                                                                options?: GetDocumentNodeFromSchemaOptions
                                                                                                ) => DocumentNode;

                                                                                                  function getFieldsWithDirectives

                                                                                                  getFieldsWithDirectives: (
                                                                                                  documentNode: DocumentNode,
                                                                                                  options?: Options
                                                                                                  ) => TypeAndFieldToDirectives;

                                                                                                    function getImplementingTypes

                                                                                                    getImplementingTypes: (interfaceName: string, schema: GraphQLSchema) => string[];

                                                                                                      function getLeadingCommentBlock

                                                                                                      getLeadingCommentBlock: (node: { loc?: Location }) => void | string;

                                                                                                        function getOperationASTFromDocument

                                                                                                        getOperationASTFromDocument: (
                                                                                                        documentNode: DocumentNode,
                                                                                                        operationName?: string
                                                                                                        ) => OperationDefinitionNode;

                                                                                                          function getOperationASTFromRequest

                                                                                                          getOperationASTFromRequest: (
                                                                                                          request: ExecutionRequest
                                                                                                          ) => OperationDefinitionNode;

                                                                                                            function getResolversFromSchema

                                                                                                            getResolversFromSchema: (
                                                                                                            schema: GraphQLSchema,
                                                                                                            includeDefaultMergedResolver?: boolean
                                                                                                            ) => IResolvers;

                                                                                                              function getResponseKeyFromInfo

                                                                                                              getResponseKeyFromInfo: (info: GraphQLResolveInfo) => string;
                                                                                                              • Get the key under which the result of this resolver will be placed in the response JSON. Basically, just resolves aliases.

                                                                                                                Parameter info

                                                                                                                The info argument to the resolver.

                                                                                                              function getRootTypeMap

                                                                                                              getRootTypeMap: (
                                                                                                              schema: GraphQLSchema
                                                                                                              ) => Map<OperationTypeNode, GraphQLObjectType>;

                                                                                                                function getRootTypeNames

                                                                                                                getRootTypeNames: (schema: GraphQLSchema) => Set<string>;

                                                                                                                  function getRootTypes

                                                                                                                  getRootTypes: (schema: GraphQLSchema) => Set<GraphQLObjectType>;

                                                                                                                    function healSchema

                                                                                                                    healSchema: (schema: GraphQLSchema) => GraphQLSchema;

                                                                                                                      function healTypes

                                                                                                                      healTypes: (
                                                                                                                      originalTypeMap: Record<string, GraphQLNamedType | null>,
                                                                                                                      directives: ReadonlyArray<GraphQLDirective>
                                                                                                                      ) => void;

                                                                                                                        function implementsAbstractType

                                                                                                                        implementsAbstractType: (
                                                                                                                        schema: GraphQLSchema,
                                                                                                                        typeA: GraphQLType,
                                                                                                                        typeB: GraphQLType
                                                                                                                        ) => boolean;

                                                                                                                          function inspect

                                                                                                                          inspect: (value: unknown) => string;
                                                                                                                          • Used to print values in error messages.

                                                                                                                          function isAggregateError

                                                                                                                          isAggregateError: (error: Error) => error is AggregateError;

                                                                                                                            function isAsyncIterable

                                                                                                                            isAsyncIterable: <T>(value: any) => value is AsyncIterable<T>;

                                                                                                                              function isDescribable

                                                                                                                              isDescribable: (node: ASTNode) => node is any;

                                                                                                                                function isDocumentNode

                                                                                                                                isDocumentNode: (object: any) => object is DocumentNode;

                                                                                                                                  function isDocumentString

                                                                                                                                  isDocumentString: (str: any) => boolean;

                                                                                                                                    function isNamedStub

                                                                                                                                    isNamedStub: (type: GraphQLNamedType) => boolean;

                                                                                                                                      function isSome

                                                                                                                                      isSome: <T>(input: T) => input is Exclude<T, null>;

                                                                                                                                        function isValidPath

                                                                                                                                        isValidPath: (str: any) => boolean;

                                                                                                                                          function makeDeprecatedDirective

                                                                                                                                          makeDeprecatedDirective: (deprecationReason: string) => DirectiveNode;

                                                                                                                                            function makeDirectiveNode

                                                                                                                                            makeDirectiveNode: (
                                                                                                                                            name: string,
                                                                                                                                            args: Record<string, any>,
                                                                                                                                            directive?: GraphQLDirective
                                                                                                                                            ) => DirectiveNode;

                                                                                                                                              function makeDirectiveNodes

                                                                                                                                              makeDirectiveNodes: (
                                                                                                                                              schema: GraphQLSchema,
                                                                                                                                              directiveValues: Record<string, any>
                                                                                                                                              ) => Array<DirectiveNode>;

                                                                                                                                                function mapAsyncIterator

                                                                                                                                                mapAsyncIterator: <T, U>(
                                                                                                                                                iterator: AsyncIterator<T>,
                                                                                                                                                callback: (value: T) => Promise<U> | U,
                                                                                                                                                rejectCallback?: any
                                                                                                                                                ) => AsyncIterableIterator<U>;
                                                                                                                                                • Given an AsyncIterable and a callback function, return an AsyncIterator which produces values mapped via calling the callback function.

                                                                                                                                                function mapSchema

                                                                                                                                                mapSchema: (schema: GraphQLSchema, schemaMapper?: SchemaMapper) => GraphQLSchema;

                                                                                                                                                  function memoize1

                                                                                                                                                  memoize1: <F extends (a1: any) => any>(fn: F) => F;

                                                                                                                                                    function memoize2

                                                                                                                                                    memoize2: <F extends (a1: any, a2: any) => any>(fn: F) => F;

                                                                                                                                                      function memoize2of4

                                                                                                                                                      memoize2of4: <F extends (a1: any, a2: any, a3: any, a4: any) => any>(fn: F) => F;

                                                                                                                                                        function memoize3

                                                                                                                                                        memoize3: <F extends (a1: any, a2: any, a3: any) => any>(fn: F) => F;

                                                                                                                                                          function memoize4

                                                                                                                                                          memoize4: <F extends (a1: any, a2: any, a3: any, a4: any) => any>(fn: F) => F;

                                                                                                                                                            function memoize5

                                                                                                                                                            memoize5: <F extends (a1: any, a2: any, a3: any, a4: any, a5: any) => any>(
                                                                                                                                                            fn: F
                                                                                                                                                            ) => F;

                                                                                                                                                              function mergeDeep

                                                                                                                                                              mergeDeep: <S extends any[]>(
                                                                                                                                                              sources: S,
                                                                                                                                                              respectPrototype?: boolean
                                                                                                                                                              ) => UnboxIntersection<UnionToIntersection<BoxedTupleTypes<S>>> & any;

                                                                                                                                                                function modifyObjectFields

                                                                                                                                                                modifyObjectFields: (
                                                                                                                                                                schema: GraphQLSchema,
                                                                                                                                                                typeName: string,
                                                                                                                                                                testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean,
                                                                                                                                                                newFields: GraphQLFieldConfigMap<any, any>
                                                                                                                                                                ) => [GraphQLSchema, GraphQLFieldConfigMap<any, any>];

                                                                                                                                                                  function nodeToString

                                                                                                                                                                  nodeToString: (a: ASTNode) => string;

                                                                                                                                                                    function observableToAsyncIterable

                                                                                                                                                                    observableToAsyncIterable: <T>(
                                                                                                                                                                    observable: Observable<T>
                                                                                                                                                                    ) => AsyncIterableIterator<T>;

                                                                                                                                                                      function parseGraphQLJSON

                                                                                                                                                                      parseGraphQLJSON: (
                                                                                                                                                                      location: string,
                                                                                                                                                                      jsonContent: string,
                                                                                                                                                                      options: SchemaPrintOptions & ParseOptions
                                                                                                                                                                      ) => Source;

                                                                                                                                                                        function parseGraphQLSDL

                                                                                                                                                                        parseGraphQLSDL: (
                                                                                                                                                                        location: string | undefined,
                                                                                                                                                                        rawSDL: string,
                                                                                                                                                                        options?: GraphQLParseOptions
                                                                                                                                                                        ) => { location: string | undefined; document: DocumentNode };

                                                                                                                                                                          function parseInputValue

                                                                                                                                                                          parseInputValue: (type: GraphQLInputType, value: any) => any;

                                                                                                                                                                            function parseInputValueLiteral

                                                                                                                                                                            parseInputValueLiteral: (type: GraphQLInputType, value: any) => any;

                                                                                                                                                                              function parseSelectionSet

                                                                                                                                                                              parseSelectionSet: (
                                                                                                                                                                              selectionSet: string,
                                                                                                                                                                              options?: GraphQLParseOptions
                                                                                                                                                                              ) => SelectionSetNode;

                                                                                                                                                                                function printComment

                                                                                                                                                                                printComment: (comment: string) => string;

                                                                                                                                                                                  function printSchemaWithDirectives

                                                                                                                                                                                  printSchemaWithDirectives: (
                                                                                                                                                                                  schema: GraphQLSchema,
                                                                                                                                                                                  options?: PrintSchemaWithDirectivesOptions
                                                                                                                                                                                  ) => string;

                                                                                                                                                                                    function printWithComments

                                                                                                                                                                                    printWithComments: (ast: ASTNode) => string;
                                                                                                                                                                                    • Converts an AST into a string, using one set of reasonable formatting rules.

                                                                                                                                                                                    function pruneSchema

                                                                                                                                                                                    pruneSchema: (
                                                                                                                                                                                    schema: GraphQLSchema,
                                                                                                                                                                                    options?: PruneSchemaOptions
                                                                                                                                                                                    ) => GraphQLSchema;
                                                                                                                                                                                    • Prunes the provided schema, removing unused and empty types

                                                                                                                                                                                      Parameter schema

                                                                                                                                                                                      The schema to prune

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Additional options for removing unused types from the schema

                                                                                                                                                                                    function pushComment

                                                                                                                                                                                    pushComment: (
                                                                                                                                                                                    node: any,
                                                                                                                                                                                    entity: string,
                                                                                                                                                                                    field?: string,
                                                                                                                                                                                    argument?: string
                                                                                                                                                                                    ) => void;

                                                                                                                                                                                      function relocatedError

                                                                                                                                                                                      relocatedError: (
                                                                                                                                                                                      originalError: GraphQLError,
                                                                                                                                                                                      path?: ReadonlyArray<string | number>
                                                                                                                                                                                      ) => GraphQLError;

                                                                                                                                                                                        function removeObjectFields

                                                                                                                                                                                        removeObjectFields: (
                                                                                                                                                                                        schema: GraphQLSchema,
                                                                                                                                                                                        typeName: string,
                                                                                                                                                                                        testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean
                                                                                                                                                                                        ) => [GraphQLSchema, GraphQLFieldConfigMap<any, any>];

                                                                                                                                                                                          function renameType

                                                                                                                                                                                          renameType: {
                                                                                                                                                                                          (type: GraphQLObjectType, newTypeName: string): GraphQLObjectType;
                                                                                                                                                                                          (type: GraphQLInterfaceType, newTypeName: string): GraphQLInterfaceType;
                                                                                                                                                                                          (type: GraphQLUnionType, newTypeName: string): GraphQLUnionType;
                                                                                                                                                                                          (type: GraphQLEnumType, newTypeName: string): GraphQLEnumType;
                                                                                                                                                                                          (type: GraphQLScalarType, newTypeName: string): GraphQLScalarType;
                                                                                                                                                                                          (type: GraphQLInputObjectType, newTypeName: string): GraphQLInputObjectType;
                                                                                                                                                                                          (type: GraphQLNamedType, newTypeName: string): GraphQLNamedType;
                                                                                                                                                                                          };

                                                                                                                                                                                            function resetComments

                                                                                                                                                                                            resetComments: () => void;

                                                                                                                                                                                              function rewireTypes

                                                                                                                                                                                              rewireTypes: (
                                                                                                                                                                                              originalTypeMap: Record<string, GraphQLNamedType | null>,
                                                                                                                                                                                              directives: ReadonlyArray<GraphQLDirective>
                                                                                                                                                                                              ) => {
                                                                                                                                                                                              typeMap: Record<string, GraphQLNamedType>;
                                                                                                                                                                                              directives: Array<GraphQLDirective>;
                                                                                                                                                                                              };

                                                                                                                                                                                                function selectObjectFields

                                                                                                                                                                                                selectObjectFields: (
                                                                                                                                                                                                schema: GraphQLSchema,
                                                                                                                                                                                                typeName: string,
                                                                                                                                                                                                testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean
                                                                                                                                                                                                ) => GraphQLFieldConfigMap<any, any>;

                                                                                                                                                                                                  function serializeInputValue

                                                                                                                                                                                                  serializeInputValue: (type: GraphQLInputType, value: any) => any;

                                                                                                                                                                                                    function transformCommentsToDescriptions

                                                                                                                                                                                                    transformCommentsToDescriptions: (
                                                                                                                                                                                                    sourceSdl: string,
                                                                                                                                                                                                    options?: GraphQLParseOptions
                                                                                                                                                                                                    ) => DocumentNode;

                                                                                                                                                                                                      function transformInputValue

                                                                                                                                                                                                      transformInputValue: (
                                                                                                                                                                                                      type: GraphQLInputType,
                                                                                                                                                                                                      value: any,
                                                                                                                                                                                                      inputLeafValueTransformer?: Maybe<InputLeafValueTransformer>,
                                                                                                                                                                                                      inputObjectValueTransformer?: Maybe<InputObjectValueTransformer>
                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                        function updateArgument

                                                                                                                                                                                                        updateArgument: (
                                                                                                                                                                                                        argumentNodes: Record<string, ArgumentNode>,
                                                                                                                                                                                                        variableDefinitionsMap: Record<string, VariableDefinitionNode>,
                                                                                                                                                                                                        variableValues: Record<string, any>,
                                                                                                                                                                                                        argName: string,
                                                                                                                                                                                                        varName: string,
                                                                                                                                                                                                        type: GraphQLInputType,
                                                                                                                                                                                                        value: any
                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                          function validateGraphQlDocuments

                                                                                                                                                                                                          validateGraphQlDocuments: (
                                                                                                                                                                                                          schema: GraphQLSchema,
                                                                                                                                                                                                          documentFiles: Source[],
                                                                                                                                                                                                          effectiveRules?: ValidationRule[]
                                                                                                                                                                                                          ) => Promise<ReadonlyArray<LoadDocumentError>>;

                                                                                                                                                                                                            function valueMatchesCriteria

                                                                                                                                                                                                            valueMatchesCriteria: (value: any, criteria: any) => boolean;

                                                                                                                                                                                                              function visitData

                                                                                                                                                                                                              visitData: (data: any, enter?: ValueVisitor, leave?: ValueVisitor) => any;

                                                                                                                                                                                                                function visitErrors

                                                                                                                                                                                                                visitErrors: (
                                                                                                                                                                                                                errors: ReadonlyArray<GraphQLError>,
                                                                                                                                                                                                                visitor: (error: GraphQLError) => GraphQLError
                                                                                                                                                                                                                ) => Array<GraphQLError>;

                                                                                                                                                                                                                  function visitResult

                                                                                                                                                                                                                  visitResult: (
                                                                                                                                                                                                                  result: ExecutionResult,
                                                                                                                                                                                                                  request: ExecutionRequest,
                                                                                                                                                                                                                  schema: GraphQLSchema,
                                                                                                                                                                                                                  resultVisitorMap?: ResultVisitorMap,
                                                                                                                                                                                                                  errorVisitorMap?: ErrorVisitorMap
                                                                                                                                                                                                                  ) => any;

                                                                                                                                                                                                                    function withCancel

                                                                                                                                                                                                                    withCancel: <T, TAsyncIterable extends AsyncIterable<T>, TReturn = any>(
                                                                                                                                                                                                                    asyncIterable: TAsyncIterable,
                                                                                                                                                                                                                    onCancel: (value?: TReturn) => void | Promise<void>
                                                                                                                                                                                                                    ) => TAsyncIterable;

                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                      interface DirectiveAnnotation

                                                                                                                                                                                                                      interface DirectiveAnnotation {}

                                                                                                                                                                                                                        property args

                                                                                                                                                                                                                        args?: Record<string, any>;

                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                            interface ExecutionRequest

                                                                                                                                                                                                                            interface ExecutionRequest<
                                                                                                                                                                                                                            TArgs extends Record<string, any> = Record<string, any>,
                                                                                                                                                                                                                            TContext = any,
                                                                                                                                                                                                                            TRootValue = any,
                                                                                                                                                                                                                            TExtensions = Record<string, any>
                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                              property context

                                                                                                                                                                                                                              context?: TContext;

                                                                                                                                                                                                                                property document

                                                                                                                                                                                                                                document: DocumentNode;

                                                                                                                                                                                                                                  property extensions

                                                                                                                                                                                                                                  extensions?: TExtensions;

                                                                                                                                                                                                                                    property info

                                                                                                                                                                                                                                    info?: GraphQLResolveInfo;

                                                                                                                                                                                                                                      property operationName

                                                                                                                                                                                                                                      operationName?: string;

                                                                                                                                                                                                                                        property operationType

                                                                                                                                                                                                                                        operationType?: OperationTypeNode;

                                                                                                                                                                                                                                          property rootValue

                                                                                                                                                                                                                                          rootValue?: TRootValue;

                                                                                                                                                                                                                                            property variables

                                                                                                                                                                                                                                            variables?: TArgs;

                                                                                                                                                                                                                                              interface GetDocumentNodeFromSchemaOptions

                                                                                                                                                                                                                                              interface GetDocumentNodeFromSchemaOptions {}

                                                                                                                                                                                                                                                property pathToDirectivesInExtensions

                                                                                                                                                                                                                                                pathToDirectivesInExtensions?: Array<string>;

                                                                                                                                                                                                                                                  interface GraphQLParseOptions

                                                                                                                                                                                                                                                  interface GraphQLParseOptions {}

                                                                                                                                                                                                                                                    property allowLegacySDLEmptyFields

                                                                                                                                                                                                                                                    allowLegacySDLEmptyFields?: boolean;

                                                                                                                                                                                                                                                      property allowLegacySDLImplementsInterfaces

                                                                                                                                                                                                                                                      allowLegacySDLImplementsInterfaces?: boolean;

                                                                                                                                                                                                                                                        property commentDescriptions

                                                                                                                                                                                                                                                        commentDescriptions?: boolean;
                                                                                                                                                                                                                                                        • Set to true in order to convert all GraphQL comments (marked with # sign) to descriptions (""") GraphQL has built-in support for transforming descriptions to comments (with print), but not while parsing. Turning the flag on will support the other way as well (parse)

                                                                                                                                                                                                                                                        property experimentalFragmentVariables

                                                                                                                                                                                                                                                        experimentalFragmentVariables?: boolean;

                                                                                                                                                                                                                                                          property noLocation

                                                                                                                                                                                                                                                          noLocation?: boolean;

                                                                                                                                                                                                                                                            interface IAddResolversToSchemaOptions

                                                                                                                                                                                                                                                            interface IAddResolversToSchemaOptions {}
                                                                                                                                                                                                                                                            • Configuration object for adding resolvers to a schema

                                                                                                                                                                                                                                                            property defaultFieldResolver

                                                                                                                                                                                                                                                            defaultFieldResolver?: IFieldResolver<any, any>;
                                                                                                                                                                                                                                                            • Override the default field resolver provided by graphql-js

                                                                                                                                                                                                                                                            property inheritResolversFromInterfaces

                                                                                                                                                                                                                                                            inheritResolversFromInterfaces?: boolean;
                                                                                                                                                                                                                                                            • GraphQL object types that implement interfaces will inherit any missing resolvers from their interface types defined in the resolvers object

                                                                                                                                                                                                                                                            property resolvers

                                                                                                                                                                                                                                                            resolvers: IResolvers;
                                                                                                                                                                                                                                                            • Object describing the field resolvers to add to the provided schema

                                                                                                                                                                                                                                                            property resolverValidationOptions

                                                                                                                                                                                                                                                            resolverValidationOptions?: IResolverValidationOptions;
                                                                                                                                                                                                                                                            • Additional options for validating the provided resolvers

                                                                                                                                                                                                                                                            property schema

                                                                                                                                                                                                                                                            schema: GraphQLSchema;
                                                                                                                                                                                                                                                            • The schema to which to add resolvers

                                                                                                                                                                                                                                                            property updateResolversInPlace

                                                                                                                                                                                                                                                            updateResolversInPlace?: boolean;
                                                                                                                                                                                                                                                            • Set to true to modify the existing schema instead of creating a new one

                                                                                                                                                                                                                                                            interface IFieldResolverOptions

                                                                                                                                                                                                                                                            interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {}

                                                                                                                                                                                                                                                              property args

                                                                                                                                                                                                                                                              args?: Array<GraphQLArgument>;

                                                                                                                                                                                                                                                                property astNode

                                                                                                                                                                                                                                                                astNode?: FieldDefinitionNode;

                                                                                                                                                                                                                                                                  property deprecationReason

                                                                                                                                                                                                                                                                  deprecationReason?: string;

                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                    description?: string;

                                                                                                                                                                                                                                                                      property extensions

                                                                                                                                                                                                                                                                      extensions?: Record<string, any>;

                                                                                                                                                                                                                                                                        property isDeprecated

                                                                                                                                                                                                                                                                        isDeprecated?: boolean;

                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                            property resolve

                                                                                                                                                                                                                                                                            resolve?: IFieldResolver<TSource, TContext, TArgs>;

                                                                                                                                                                                                                                                                              property subscribe

                                                                                                                                                                                                                                                                              subscribe?: IFieldResolver<TSource, TContext, TArgs>;

                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                type?: GraphQLOutputType;

                                                                                                                                                                                                                                                                                  interface IResolverValidationOptions

                                                                                                                                                                                                                                                                                  interface IResolverValidationOptions {}
                                                                                                                                                                                                                                                                                  • Options for validating resolvers

                                                                                                                                                                                                                                                                                  property requireResolversForAllFields

                                                                                                                                                                                                                                                                                  requireResolversForAllFields?: ValidatorBehavior;
                                                                                                                                                                                                                                                                                  • Enable to require a resolver for be defined for all fields defined in the schema. Defaults to ignore.

                                                                                                                                                                                                                                                                                  property requireResolversForArgs

                                                                                                                                                                                                                                                                                  requireResolversForArgs?: ValidatorBehavior;
                                                                                                                                                                                                                                                                                  • Enable to require a resolver to be defined for any field that has arguments. Defaults to ignore.

                                                                                                                                                                                                                                                                                  property requireResolversForNonScalar

                                                                                                                                                                                                                                                                                  requireResolversForNonScalar?: ValidatorBehavior;
                                                                                                                                                                                                                                                                                  • Enable to require a resolver to be defined for any field which has a return type that isn't a scalar. Defaults to ignore.

                                                                                                                                                                                                                                                                                  property requireResolversForResolveType

                                                                                                                                                                                                                                                                                  requireResolversForResolveType?: ValidatorBehavior;
                                                                                                                                                                                                                                                                                  • Enable to require a resolveType() for Interface and Union types. Defaults to ignore.

                                                                                                                                                                                                                                                                                  property requireResolversToMatchSchema

                                                                                                                                                                                                                                                                                  requireResolversToMatchSchema?: ValidatorBehavior;
                                                                                                                                                                                                                                                                                  • Enable to require all defined resolvers to match fields that actually exist in the schema. Defaults to error to catch common errors.

                                                                                                                                                                                                                                                                                  interface LoadDocumentError

                                                                                                                                                                                                                                                                                  interface LoadDocumentError {}

                                                                                                                                                                                                                                                                                    property errors

                                                                                                                                                                                                                                                                                    readonly errors: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                                                      property filePath

                                                                                                                                                                                                                                                                                      readonly filePath?: string;

                                                                                                                                                                                                                                                                                        interface Loader

                                                                                                                                                                                                                                                                                        interface Loader<TOptions extends BaseLoaderOptions = BaseLoaderOptions> {}

                                                                                                                                                                                                                                                                                          method load

                                                                                                                                                                                                                                                                                          load: (pointer: string, options?: TOptions) => Promise<Source[] | null | never>;

                                                                                                                                                                                                                                                                                            method loadSync

                                                                                                                                                                                                                                                                                            loadSync: (pointer: string, options?: TOptions) => Source[] | null | never;

                                                                                                                                                                                                                                                                                              interface Observable

                                                                                                                                                                                                                                                                                              interface Observable<T> {}

                                                                                                                                                                                                                                                                                                method subscribe

                                                                                                                                                                                                                                                                                                subscribe: (observer: Observer<T>) => { unsubscribe: () => void };

                                                                                                                                                                                                                                                                                                  interface Observer

                                                                                                                                                                                                                                                                                                  interface Observer<T> {}

                                                                                                                                                                                                                                                                                                    property complete

                                                                                                                                                                                                                                                                                                    complete: () => void;

                                                                                                                                                                                                                                                                                                      property error

                                                                                                                                                                                                                                                                                                      error: (error: Error) => void;

                                                                                                                                                                                                                                                                                                        property next

                                                                                                                                                                                                                                                                                                        next: (value: T) => void;

                                                                                                                                                                                                                                                                                                          interface PruneSchemaOptions

                                                                                                                                                                                                                                                                                                          interface PruneSchemaOptions {}
                                                                                                                                                                                                                                                                                                          • Options for removing unused types from the schema

                                                                                                                                                                                                                                                                                                          property skipEmptyCompositeTypePruning

                                                                                                                                                                                                                                                                                                          skipEmptyCompositeTypePruning?: boolean;
                                                                                                                                                                                                                                                                                                          • Set to true to skip pruning object types or interfaces with no no fields

                                                                                                                                                                                                                                                                                                          property skipEmptyUnionPruning

                                                                                                                                                                                                                                                                                                          skipEmptyUnionPruning?: boolean;
                                                                                                                                                                                                                                                                                                          • Set to true to skip pruning empty unions

                                                                                                                                                                                                                                                                                                          property skipPruning

                                                                                                                                                                                                                                                                                                          skipPruning?: PruneSchemaFilter;
                                                                                                                                                                                                                                                                                                          • Return true to skip pruning this type. This check will run first before any other options. This can be helpful for schemas that support type extensions like Apollo Federation.

                                                                                                                                                                                                                                                                                                          property skipUnimplementedInterfacesPruning

                                                                                                                                                                                                                                                                                                          skipUnimplementedInterfacesPruning?: boolean;
                                                                                                                                                                                                                                                                                                          • Set to true to skip pruning interfaces that are not implemented by any other types

                                                                                                                                                                                                                                                                                                          property skipUnusedTypesPruning

                                                                                                                                                                                                                                                                                                          skipUnusedTypesPruning?: boolean;
                                                                                                                                                                                                                                                                                                          • Set to true to skip pruning unused types

                                                                                                                                                                                                                                                                                                          interface SchemaMapper

                                                                                                                                                                                                                                                                                                          interface SchemaMapper {}

                                                                                                                                                                                                                                                                                                            property [MapperKind.ABSTRACT_TYPE]

                                                                                                                                                                                                                                                                                                            [MapperKind.ABSTRACT_TYPE]?: AbstractTypeMapper;

                                                                                                                                                                                                                                                                                                              property [MapperKind.ARGUMENT]

                                                                                                                                                                                                                                                                                                              [MapperKind.ARGUMENT]?: ArgumentMapper;

                                                                                                                                                                                                                                                                                                                property [MapperKind.COMPOSITE_FIELD]

                                                                                                                                                                                                                                                                                                                [MapperKind.COMPOSITE_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                  property [MapperKind.COMPOSITE_TYPE]

                                                                                                                                                                                                                                                                                                                  [MapperKind.COMPOSITE_TYPE]?: CompositeTypeMapper;

                                                                                                                                                                                                                                                                                                                    property [MapperKind.DIRECTIVE]

                                                                                                                                                                                                                                                                                                                    [MapperKind.DIRECTIVE]?: DirectiveMapper;

                                                                                                                                                                                                                                                                                                                      property [MapperKind.ENUM_TYPE]

                                                                                                                                                                                                                                                                                                                      [MapperKind.ENUM_TYPE]?: EnumTypeMapper;

                                                                                                                                                                                                                                                                                                                        property [MapperKind.ENUM_VALUE]

                                                                                                                                                                                                                                                                                                                        [MapperKind.ENUM_VALUE]?: EnumValueMapper;

                                                                                                                                                                                                                                                                                                                          property [MapperKind.FIELD]

                                                                                                                                                                                                                                                                                                                          [MapperKind.FIELD]?: GenericFieldMapper<
                                                                                                                                                                                                                                                                                                                          GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig
                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                            property [MapperKind.INPUT_OBJECT_FIELD]

                                                                                                                                                                                                                                                                                                                            [MapperKind.INPUT_OBJECT_FIELD]?: InputFieldMapper;

                                                                                                                                                                                                                                                                                                                              property [MapperKind.INPUT_OBJECT_TYPE]

                                                                                                                                                                                                                                                                                                                              [MapperKind.INPUT_OBJECT_TYPE]?: InputObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                property [MapperKind.INTERFACE_FIELD]

                                                                                                                                                                                                                                                                                                                                [MapperKind.INTERFACE_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                  property [MapperKind.INTERFACE_TYPE]

                                                                                                                                                                                                                                                                                                                                  [MapperKind.INTERFACE_TYPE]?: InterfaceTypeMapper;

                                                                                                                                                                                                                                                                                                                                    property [MapperKind.MUTATION_ROOT_FIELD]

                                                                                                                                                                                                                                                                                                                                    [MapperKind.MUTATION_ROOT_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                      property [MapperKind.MUTATION]

                                                                                                                                                                                                                                                                                                                                      [MapperKind.MUTATION]?: ObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                        property [MapperKind.OBJECT_FIELD]

                                                                                                                                                                                                                                                                                                                                        [MapperKind.OBJECT_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                          property [MapperKind.OBJECT_TYPE]

                                                                                                                                                                                                                                                                                                                                          [MapperKind.OBJECT_TYPE]?: ObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                            property [MapperKind.QUERY_ROOT_FIELD]

                                                                                                                                                                                                                                                                                                                                            [MapperKind.QUERY_ROOT_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                              property [MapperKind.QUERY]

                                                                                                                                                                                                                                                                                                                                              [MapperKind.QUERY]?: ObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                                property [MapperKind.ROOT_FIELD]

                                                                                                                                                                                                                                                                                                                                                [MapperKind.ROOT_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                                  property [MapperKind.ROOT_OBJECT]

                                                                                                                                                                                                                                                                                                                                                  [MapperKind.ROOT_OBJECT]?: ObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                                    property [MapperKind.SCALAR_TYPE]

                                                                                                                                                                                                                                                                                                                                                    [MapperKind.SCALAR_TYPE]?: ScalarTypeMapper;

                                                                                                                                                                                                                                                                                                                                                      property [MapperKind.SUBSCRIPTION_ROOT_FIELD]

                                                                                                                                                                                                                                                                                                                                                      [MapperKind.SUBSCRIPTION_ROOT_FIELD]?: FieldMapper;

                                                                                                                                                                                                                                                                                                                                                        property [MapperKind.SUBSCRIPTION]

                                                                                                                                                                                                                                                                                                                                                        [MapperKind.SUBSCRIPTION]?: ObjectTypeMapper;

                                                                                                                                                                                                                                                                                                                                                          property [MapperKind.TYPE]

                                                                                                                                                                                                                                                                                                                                                          [MapperKind.TYPE]?: NamedTypeMapper;

                                                                                                                                                                                                                                                                                                                                                            property [MapperKind.UNION_TYPE]

                                                                                                                                                                                                                                                                                                                                                            [MapperKind.UNION_TYPE]?: UnionTypeMapper;

                                                                                                                                                                                                                                                                                                                                                              interface SchemaPrintOptions

                                                                                                                                                                                                                                                                                                                                                              interface SchemaPrintOptions {}

                                                                                                                                                                                                                                                                                                                                                                property assumeValid

                                                                                                                                                                                                                                                                                                                                                                assumeValid?: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property commentDescriptions

                                                                                                                                                                                                                                                                                                                                                                  commentDescriptions?: boolean;
                                                                                                                                                                                                                                                                                                                                                                  • Descriptions are defined as preceding string literals, however an older experimental version of the SDL supported preceding comments as descriptions. Set to true to enable this deprecated behavior. This option is provided to ease adoption and will be removed in v16.

                                                                                                                                                                                                                                                                                                                                                                    Default: false

                                                                                                                                                                                                                                                                                                                                                                  interface Source

                                                                                                                                                                                                                                                                                                                                                                  interface Source {}

                                                                                                                                                                                                                                                                                                                                                                    property document

                                                                                                                                                                                                                                                                                                                                                                    document?: DocumentNode;

                                                                                                                                                                                                                                                                                                                                                                      property location

                                                                                                                                                                                                                                                                                                                                                                      location?: string;

                                                                                                                                                                                                                                                                                                                                                                        property rawSDL

                                                                                                                                                                                                                                                                                                                                                                        rawSDL?: string;

                                                                                                                                                                                                                                                                                                                                                                          property schema

                                                                                                                                                                                                                                                                                                                                                                          schema?: GraphQLSchema;

                                                                                                                                                                                                                                                                                                                                                                            Enums

                                                                                                                                                                                                                                                                                                                                                                            enum DirectiveLocation

                                                                                                                                                                                                                                                                                                                                                                            enum DirectiveLocation {
                                                                                                                                                                                                                                                                                                                                                                            QUERY = 'QUERY',
                                                                                                                                                                                                                                                                                                                                                                            MUTATION = 'MUTATION',
                                                                                                                                                                                                                                                                                                                                                                            SUBSCRIPTION = 'SUBSCRIPTION',
                                                                                                                                                                                                                                                                                                                                                                            FIELD = 'FIELD',
                                                                                                                                                                                                                                                                                                                                                                            FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION',
                                                                                                                                                                                                                                                                                                                                                                            FRAGMENT_SPREAD = 'FRAGMENT_SPREAD',
                                                                                                                                                                                                                                                                                                                                                                            INLINE_FRAGMENT = 'INLINE_FRAGMENT',
                                                                                                                                                                                                                                                                                                                                                                            VARIABLE_DEFINITION = 'VARIABLE_DEFINITION',
                                                                                                                                                                                                                                                                                                                                                                            SCHEMA = 'SCHEMA',
                                                                                                                                                                                                                                                                                                                                                                            SCALAR = 'SCALAR',
                                                                                                                                                                                                                                                                                                                                                                            OBJECT = 'OBJECT',
                                                                                                                                                                                                                                                                                                                                                                            FIELD_DEFINITION = 'FIELD_DEFINITION',
                                                                                                                                                                                                                                                                                                                                                                            ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION',
                                                                                                                                                                                                                                                                                                                                                                            INTERFACE = 'INTERFACE',
                                                                                                                                                                                                                                                                                                                                                                            UNION = 'UNION',
                                                                                                                                                                                                                                                                                                                                                                            ENUM = 'ENUM',
                                                                                                                                                                                                                                                                                                                                                                            ENUM_VALUE = 'ENUM_VALUE',
                                                                                                                                                                                                                                                                                                                                                                            INPUT_OBJECT = 'INPUT_OBJECT',
                                                                                                                                                                                                                                                                                                                                                                            INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION',
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              member ARGUMENT_DEFINITION

                                                                                                                                                                                                                                                                                                                                                                              ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION'

                                                                                                                                                                                                                                                                                                                                                                                member ENUM

                                                                                                                                                                                                                                                                                                                                                                                ENUM = 'ENUM'

                                                                                                                                                                                                                                                                                                                                                                                  member ENUM_VALUE

                                                                                                                                                                                                                                                                                                                                                                                  ENUM_VALUE = 'ENUM_VALUE'

                                                                                                                                                                                                                                                                                                                                                                                    member FIELD

                                                                                                                                                                                                                                                                                                                                                                                    FIELD = 'FIELD'

                                                                                                                                                                                                                                                                                                                                                                                      member FIELD_DEFINITION

                                                                                                                                                                                                                                                                                                                                                                                      FIELD_DEFINITION = 'FIELD_DEFINITION'

                                                                                                                                                                                                                                                                                                                                                                                        member FRAGMENT_DEFINITION

                                                                                                                                                                                                                                                                                                                                                                                        FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION'

                                                                                                                                                                                                                                                                                                                                                                                          member FRAGMENT_SPREAD

                                                                                                                                                                                                                                                                                                                                                                                          FRAGMENT_SPREAD = 'FRAGMENT_SPREAD'

                                                                                                                                                                                                                                                                                                                                                                                            member INLINE_FRAGMENT

                                                                                                                                                                                                                                                                                                                                                                                            INLINE_FRAGMENT = 'INLINE_FRAGMENT'

                                                                                                                                                                                                                                                                                                                                                                                              member INPUT_FIELD_DEFINITION

                                                                                                                                                                                                                                                                                                                                                                                              INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION'

                                                                                                                                                                                                                                                                                                                                                                                                member INPUT_OBJECT

                                                                                                                                                                                                                                                                                                                                                                                                INPUT_OBJECT = 'INPUT_OBJECT'

                                                                                                                                                                                                                                                                                                                                                                                                  member INTERFACE

                                                                                                                                                                                                                                                                                                                                                                                                  INTERFACE = 'INTERFACE'

                                                                                                                                                                                                                                                                                                                                                                                                    member MUTATION

                                                                                                                                                                                                                                                                                                                                                                                                    MUTATION = 'MUTATION'

                                                                                                                                                                                                                                                                                                                                                                                                      member OBJECT

                                                                                                                                                                                                                                                                                                                                                                                                      OBJECT = 'OBJECT'

                                                                                                                                                                                                                                                                                                                                                                                                        member QUERY

                                                                                                                                                                                                                                                                                                                                                                                                        QUERY = 'QUERY'
                                                                                                                                                                                                                                                                                                                                                                                                        • Request Definitions

                                                                                                                                                                                                                                                                                                                                                                                                        member SCALAR

                                                                                                                                                                                                                                                                                                                                                                                                        SCALAR = 'SCALAR'

                                                                                                                                                                                                                                                                                                                                                                                                          member SCHEMA

                                                                                                                                                                                                                                                                                                                                                                                                          SCHEMA = 'SCHEMA'
                                                                                                                                                                                                                                                                                                                                                                                                          • Type System Definitions

                                                                                                                                                                                                                                                                                                                                                                                                          member SUBSCRIPTION

                                                                                                                                                                                                                                                                                                                                                                                                          SUBSCRIPTION = 'SUBSCRIPTION'

                                                                                                                                                                                                                                                                                                                                                                                                            member UNION

                                                                                                                                                                                                                                                                                                                                                                                                            UNION = 'UNION'

                                                                                                                                                                                                                                                                                                                                                                                                              member VARIABLE_DEFINITION

                                                                                                                                                                                                                                                                                                                                                                                                              VARIABLE_DEFINITION = 'VARIABLE_DEFINITION'

                                                                                                                                                                                                                                                                                                                                                                                                                enum MapperKind

                                                                                                                                                                                                                                                                                                                                                                                                                enum MapperKind {
                                                                                                                                                                                                                                                                                                                                                                                                                TYPE = 'MapperKind.TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                SCALAR_TYPE = 'MapperKind.SCALAR_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                ENUM_TYPE = 'MapperKind.ENUM_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                COMPOSITE_TYPE = 'MapperKind.COMPOSITE_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                OBJECT_TYPE = 'MapperKind.OBJECT_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                INPUT_OBJECT_TYPE = 'MapperKind.INPUT_OBJECT_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                ABSTRACT_TYPE = 'MapperKind.ABSTRACT_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                UNION_TYPE = 'MapperKind.UNION_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                INTERFACE_TYPE = 'MapperKind.INTERFACE_TYPE',
                                                                                                                                                                                                                                                                                                                                                                                                                ROOT_OBJECT = 'MapperKind.ROOT_OBJECT',
                                                                                                                                                                                                                                                                                                                                                                                                                QUERY = 'MapperKind.QUERY',
                                                                                                                                                                                                                                                                                                                                                                                                                MUTATION = 'MapperKind.MUTATION',
                                                                                                                                                                                                                                                                                                                                                                                                                SUBSCRIPTION = 'MapperKind.SUBSCRIPTION',
                                                                                                                                                                                                                                                                                                                                                                                                                DIRECTIVE = 'MapperKind.DIRECTIVE',
                                                                                                                                                                                                                                                                                                                                                                                                                FIELD = 'MapperKind.FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                COMPOSITE_FIELD = 'MapperKind.COMPOSITE_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                OBJECT_FIELD = 'MapperKind.OBJECT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                ROOT_FIELD = 'MapperKind.ROOT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                QUERY_ROOT_FIELD = 'MapperKind.QUERY_ROOT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                MUTATION_ROOT_FIELD = 'MapperKind.MUTATION_ROOT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                SUBSCRIPTION_ROOT_FIELD = 'MapperKind.SUBSCRIPTION_ROOT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                INTERFACE_FIELD = 'MapperKind.INTERFACE_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                INPUT_OBJECT_FIELD = 'MapperKind.INPUT_OBJECT_FIELD',
                                                                                                                                                                                                                                                                                                                                                                                                                ARGUMENT = 'MapperKind.ARGUMENT',
                                                                                                                                                                                                                                                                                                                                                                                                                ENUM_VALUE = 'MapperKind.ENUM_VALUE',
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  member ABSTRACT_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                  ABSTRACT_TYPE = 'MapperKind.ABSTRACT_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                    member ARGUMENT

                                                                                                                                                                                                                                                                                                                                                                                                                    ARGUMENT = 'MapperKind.ARGUMENT'

                                                                                                                                                                                                                                                                                                                                                                                                                      member COMPOSITE_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                      COMPOSITE_FIELD = 'MapperKind.COMPOSITE_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                        member COMPOSITE_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                        COMPOSITE_TYPE = 'MapperKind.COMPOSITE_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                          member DIRECTIVE

                                                                                                                                                                                                                                                                                                                                                                                                                          DIRECTIVE = 'MapperKind.DIRECTIVE'

                                                                                                                                                                                                                                                                                                                                                                                                                            member ENUM_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                            ENUM_TYPE = 'MapperKind.ENUM_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                              member ENUM_VALUE

                                                                                                                                                                                                                                                                                                                                                                                                                              ENUM_VALUE = 'MapperKind.ENUM_VALUE'

                                                                                                                                                                                                                                                                                                                                                                                                                                member FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                FIELD = 'MapperKind.FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                  member INPUT_OBJECT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                  INPUT_OBJECT_FIELD = 'MapperKind.INPUT_OBJECT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                    member INPUT_OBJECT_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                    INPUT_OBJECT_TYPE = 'MapperKind.INPUT_OBJECT_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                      member INTERFACE_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                      INTERFACE_FIELD = 'MapperKind.INTERFACE_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                        member INTERFACE_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                        INTERFACE_TYPE = 'MapperKind.INTERFACE_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                          member MUTATION

                                                                                                                                                                                                                                                                                                                                                                                                                                          MUTATION = 'MapperKind.MUTATION'

                                                                                                                                                                                                                                                                                                                                                                                                                                            member MUTATION_ROOT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                            MUTATION_ROOT_FIELD = 'MapperKind.MUTATION_ROOT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                              member OBJECT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                              OBJECT_FIELD = 'MapperKind.OBJECT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                member OBJECT_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                OBJECT_TYPE = 'MapperKind.OBJECT_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                  member QUERY

                                                                                                                                                                                                                                                                                                                                                                                                                                                  QUERY = 'MapperKind.QUERY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member QUERY_ROOT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                                    QUERY_ROOT_FIELD = 'MapperKind.QUERY_ROOT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                      member ROOT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ROOT_FIELD = 'MapperKind.ROOT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                        member ROOT_OBJECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ROOT_OBJECT = 'MapperKind.ROOT_OBJECT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                          member SCALAR_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                          SCALAR_TYPE = 'MapperKind.SCALAR_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                            member SUBSCRIPTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                            SUBSCRIPTION = 'MapperKind.SUBSCRIPTION'

                                                                                                                                                                                                                                                                                                                                                                                                                                                              member SUBSCRIPTION_ROOT_FIELD

                                                                                                                                                                                                                                                                                                                                                                                                                                                              SUBSCRIPTION_ROOT_FIELD = 'MapperKind.SUBSCRIPTION_ROOT_FIELD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                member TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                TYPE = 'MapperKind.TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member UNION_TYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UNION_TYPE = 'MapperKind.UNION_TYPE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AbstractTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AbstractTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: GraphQLInterfaceType | GraphQLUnionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => GraphQLInterfaceType | GraphQLUnionType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ArgumentFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ArgumentFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      argName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      argConfig?: GraphQLArgumentConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ArgumentMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ArgumentMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        argumentConfig: GraphQLArgumentConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => GraphQLArgumentConfig | [string, GraphQLArgumentConfig] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ASTVisitorKeyMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ASTVisitorKeyMap = Partial<Parameters<typeof visit>[2]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AsyncExecutor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AsyncExecutor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > = <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TReturn = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TArgs extends Record<string, any> = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TContext extends TBaseContext = TBaseContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TRoot = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TExtensions extends TBaseExtensions = TBaseExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<MaybeAsyncIterable<ExecutionResult<TReturn>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BaseLoaderOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BaseLoaderOptions = GraphQLParseOptions &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BuildSchemaOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cwd?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ignore?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Callback = (value?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CompositeTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CompositeTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Constructor<T> = new (...args: any[]) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DirectiveArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DirectiveArgs = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DirectiveLocationEnum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DirectiveLocationEnum = typeof DirectiveLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DirectiveMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DirectiveMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directive: GraphQLDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => GraphQLDirective | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DirectiveUsage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DirectiveUsage = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: DirectiveArgs;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ElementOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ElementOf<TList> = TList extends Array<infer TElement> ? TElement : never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnumTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnumTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: GraphQLEnumType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => GraphQLEnumType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnumValueMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnumValueMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  valueConfig: GraphQLEnumValueConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  schema: GraphQLSchema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  externalValue: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => GraphQLEnumValueConfig | [string, GraphQLEnumValueConfig] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrorVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrorVisitor = (error: GraphQLError, pathIndex: number) => GraphQLError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ErrorVisitorMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ErrorVisitorMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __unpathed?: (error: GraphQLError) => GraphQLError;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & Record<string, Record<string, ErrorVisitor>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ExecutionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ExecutionResult<TData = Record<string, any>> = GraphQLExecutionResult & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data?: TData | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Executor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Executor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > = <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TReturn = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TArgs extends Record<string, any> = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TContext extends TBaseContext = TBaseContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TRoot = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TExtensions extends TBaseExtensions = TBaseExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => MaybePromise<MaybeAsyncIterable<ExecutionResult<TReturn>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FieldFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FieldFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldConfig: GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FieldMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FieldMapper = GenericFieldMapper<GraphQLFieldConfig<any, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FieldNodeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FieldNodeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fieldNode: FieldNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fragments: Record<string, FragmentDefinitionNode>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transformationContext: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => SelectionNode | Array<SelectionNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FieldNodeMappers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FieldNodeMappers = Record<string, Record<string, FieldNodeMapper>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Force = string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GenericFieldMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GenericFieldMapper<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      F extends GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldConfig: F,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => F | [string, F] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IDefaultValueIteratorFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IDefaultValueIteratorFn = (type: GraphQLInputType, value: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IEnumTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IEnumTypeResolver = Record<string, any> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __astNode?: EnumTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __extensionASTNodes?: Array<EnumTypeExtensionNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IFieldIteratorFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IFieldIteratorFn = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldDef: GraphQLField<any, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IFieldResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IFieldResolver<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TSource,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TArgs = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TReturn = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              source: TSource,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              args: TArgs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: TContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              info: GraphQLResolveInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => TReturn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Ignore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Ignore = string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IInputObjectTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IInputObjectTypeResolver = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __astNode?: InputObjectTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __extensionASTNodes?: Array<InputObjectTypeExtensionNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IInterfaceTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IInterfaceTypeResolver<TSource = any, TContext = any, TArgs = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IFieldResolver<TSource, TContext, TArgs>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IFieldResolverOptions<TSource, TContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __resolveType?: GraphQLTypeResolver<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __astNode?: InterfaceTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    __extensionASTNodes?: Array<InterfaceTypeExtensionNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputFieldFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputFieldFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inputFieldConfig?: GraphQLInputFieldConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputFieldMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputFieldMapper = GenericFieldMapper<GraphQLInputFieldConfig>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputLeafValueTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputLeafValueTransformer = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: GraphQLEnumType | GraphQLScalarType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          originalValue: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputObjectTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputObjectTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: GraphQLInputObjectType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => GraphQLInputObjectType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputObjectValueTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputObjectValueTransformer = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: GraphQLInputObjectType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              originalValue: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InterfaceTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InterfaceTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: GraphQLInterfaceType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => GraphQLInterfaceType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IObjectTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IObjectTypeResolver<TSource = any, TContext = any, TArgs = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | IFieldResolver<TSource, TContext, TArgs>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | IFieldResolverOptions<TSource, TContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __astNode?: ObjectTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __extensionASTNodes?: ObjectTypeExtensionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IResolvers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IResolvers<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSource = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TContext = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TArgs = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TReturn = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > = Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ISchemaLevelResolver<TSource, TContext, TArgs, TReturn>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IObjectTypeResolver<TSource, TContext>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IInterfaceTypeResolver<TSource, TContext>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IUnionTypeResolver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IScalarTypeResolver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IEnumTypeResolver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IInputObjectTypeResolver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IScalarTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IScalarTypeResolver = GraphQLScalarType & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __serialize?: GraphQLScalarSerializer<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __parseValue?: GraphQLScalarValueParser<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __parseLiteral?: GraphQLScalarLiteralParser<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __astNode?: ScalarTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      __extensionASTNodes?: Array<ScalarTypeExtensionNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ISchemaLevelResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ISchemaLevelResolver<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSource,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TArgs = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TReturn = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = IFieldResolver<TSource, TContext, TArgs, TReturn>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IUnionTypeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IUnionTypeResolver = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __resolveType?: GraphQLTypeResolver<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __extensions?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __astNode?: UnionTypeDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __extensionASTNodes?: Array<UnionTypeExtensionNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Maybe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Maybe<T> = null | undefined | T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NamedDefinitionNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NamedDefinitionNode = DefinitionNode & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name?: NameNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NamedTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NamedTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: GraphQLNamedType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => GraphQLNamedType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NextResolverFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NextResolverFn = () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ObjectFieldFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ObjectFieldFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fieldConfig: GraphQLFieldConfig<any, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: GraphQLObjectType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => GraphQLObjectType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ObjectValueVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ObjectValueVisitor = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        __enter?: ValueVisitor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        __leave?: ValueVisitor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & Record<string, ValueVisitor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrintSchemaWithDirectivesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrintSchemaWithDirectivesOptions = SchemaPrintOptions &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetDocumentNodeFromSchemaOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PruneSchemaFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PruneSchemaFilter = (type: GraphQLNamedType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RenameTypesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RenameTypesOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renameBuiltins: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renameScalars: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ResultVisitorMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ResultVisitorMap = Record<string, ValueVisitor | ObjectValueVisitor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RootFieldFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RootFieldFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  operation: 'Query' | 'Mutation' | 'Subscription',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rootFieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fieldConfig: GraphQLFieldConfig<any, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScalarTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScalarTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: GraphQLScalarType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => GraphQLScalarType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaFieldMapperTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaFieldMapperTypes = Array<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.COMPOSITE_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.OBJECT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.ROOT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.QUERY_ROOT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.MUTATION_ROOT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.SUBSCRIPTION_ROOT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.INTERFACE_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MapperKind.INPUT_OBJECT_FIELD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SelectedFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SelectedFields =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: SelectedFields;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Skip = string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SyncExecutor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SyncExecutor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > = <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TReturn = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TArgs extends Record<string, any> = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TContext extends TBaseContext = TBaseContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TRoot = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TExtensions extends TBaseExtensions = TBaseExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => ExecutionResult<TReturn>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeAndFieldToDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeAndFieldToDirectives = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [typeAndField: string]: DirectiveUsage[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TypeFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TypeFilter = (typeName: string, type: GraphQLType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypeSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypeSource =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Source
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | DocumentNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | DefinitionNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Array<TypeSource>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | (() => TypeSource);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UnionTypeMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UnionTypeMapper = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: GraphQLUnionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema: GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => GraphQLUnionType | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ValidationRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ValidationRule = (context: ValidationContext) => ASTVisitor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ValidatorBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ValidatorBehavior = 'error' | 'warn' | 'ignore';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ValueVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ValueVisitor = (value: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VisitableSchemaType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VisitableSchemaType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLObjectType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLInterfaceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLInputObjectType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLNamedType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLScalarType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLField<any, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLInputField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLArgument
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLUnionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLEnumType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GraphQLEnumValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type WithList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type WithList<T> = T | T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (50)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@graphql-tools/utils.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@graphql-tools/utils)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@graphql-tools/utils"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>