@graphql-tools/utils

  • Version 10.8.6
  • Published
  • 509 kB
  • 5 dependencies
  • 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 GraphQLDeferDirective

const GraphQLDeferDirective: GraphQLDirective;
  • Used to conditionally defer fragments.

variable GraphQLStreamDirective

const GraphQLStreamDirective: GraphQLDirective;
  • Used to conditionally stream list fields.

Functions

function addPath

addPath: (
prev: Readonly<Path> | undefined,
key: string | number,
typename: string | undefined
) => Path;
  • Given a Path and a key, return a new Path containing the new key.

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 astFromType

                                astFromType: (type: GraphQLType) => TypeNode;

                                  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 | | BigInt | Int | | 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 collectComment

                                      collectComment: (node: NamedDefinitionNode) => void;

                                        function collectFields

                                        collectFields: <TVariables = any>(
                                        schema: GraphQLSchema,
                                        fragments: Record<string, FragmentDefinitionNode>,
                                        variableValues: TVariables,
                                        runtimeType: GraphQLObjectType,
                                        selectionSet: SelectionSetNode
                                        ) => FieldsAndPatches;
                                        • Given a selectionSet, collects all of the fields and returns them.

                                          CollectFields requires the "runtime type" of an object. For a field that returns an Interface or Union type, the "runtime type" will be the actual object type returned by that field.

                                        function collectSubFields

                                        collectSubFields: (
                                        schema: GraphQLSchema,
                                        fragments: Record<string, FragmentDefinitionNode>,
                                        variableValues: { [variable: string]: unknown },
                                        returnType: GraphQLObjectType,
                                        fieldNodes: Array<FieldNode>
                                        ) => FieldsAndPatches;
                                        • Given an array of field nodes, collects all of the subfields of the passed in fields, and returns them at the end.

                                          CollectSubFields requires the "return type" of an object. For a field that returns an Interface or Union type, the "return type" will be the actual object type returned by that field.

                                        function compareNodes

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

                                          function compareStrings

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

                                            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 debugTimerEnd

                                                        debugTimerEnd: (name: string) => void;

                                                          function debugTimerStart

                                                          debugTimerStart: (name: string) => void;

                                                            function dedentBlockStringValue

                                                            dedentBlockStringValue: (rawString: string) => string;

                                                              function doesFragmentConditionMatch

                                                              doesFragmentConditionMatch: (
                                                              schema: GraphQLSchema,
                                                              fragment: FragmentDefinitionNode | InlineFragmentNode,
                                                              type: GraphQLObjectType
                                                              ) => boolean;
                                                              • Determines if a fragment is applicable to the given type.

                                                              function extractExtensionsFromSchema

                                                              extractExtensionsFromSchema: (
                                                              schema: GraphQLSchema,
                                                              removeDirectives?: boolean
                                                              ) => SchemaExtensions;

                                                                function filterSchema

                                                                filterSchema: ({
                                                                schema,
                                                                typeFilter,
                                                                fieldFilter,
                                                                rootFieldFilter,
                                                                objectFieldFilter,
                                                                interfaceFieldFilter,
                                                                inputObjectFieldFilter,
                                                                argumentFilter,
                                                                directiveFilter,
                                                                enumValueFilter,
                                                                }: {
                                                                schema: GraphQLSchema;
                                                                rootFieldFilter?: RootFieldFilter;
                                                                typeFilter?: TypeFilter;
                                                                fieldFilter?: FieldFilter;
                                                                objectFieldFilter?: FieldFilter;
                                                                interfaceFieldFilter?: FieldFilter;
                                                                inputObjectFieldFilter?: FieldFilter;
                                                                argumentFilter?: ArgumentFilter;
                                                                directiveFilter?: DirectiveFilter;
                                                                enumValueFilter?: EnumValueFilter;
                                                                }) => 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 getAbortPromise

                                                                        getAbortPromise: (signal: AbortSignal) => Promise<void>;

                                                                          function getArgumentsWithDirectives

                                                                          getArgumentsWithDirectives: (
                                                                          documentNode: DocumentNode
                                                                          ) => TypeAndFieldToArgumentDirectives;

                                                                            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 getDeferValues

                                                                                    getDeferValues: (
                                                                                    variableValues: any,
                                                                                    node: FragmentSpreadNode | InlineFragmentNode
                                                                                    ) => undefined | { label: string | undefined };
                                                                                    • Returns an object containing the @defer arguments if a field should be deferred based on the experimental flag, defer directive present and not disabled by the "if" argument.

                                                                                    function getDefinedRootType

                                                                                    getDefinedRootType: (
                                                                                    schema: GraphQLSchema,
                                                                                    operation: OperationTypeNode,
                                                                                    nodes?: ASTNode[]
                                                                                    ) => GraphQLObjectType;

                                                                                      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 getDirectiveExtensions

                                                                                          getDirectiveExtensions: <
                                                                                          TDirectiveAnnotationsMap extends {
                                                                                          [directiveName: string]: { [paramName: string]: any };
                                                                                          }
                                                                                          >(
                                                                                          directableObj: DirectableObject,
                                                                                          schema?: GraphQLSchema,
                                                                                          pathToDirectivesInExtensions?: string[]
                                                                                          ) => {
                                                                                          [directiveName in keyof TDirectiveAnnotationsMap]?: TDirectiveAnnotationsMap[directiveName][];
                                                                                          };

                                                                                            function getDirectiveInExtensions

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

                                                                                              function getDirectiveNodes

                                                                                              getDirectiveNodes: <TDirectiveNode extends DirectiveNode>(
                                                                                              entity: DirectableGraphQLObject & {
                                                                                              deprecationReason?: string | null;
                                                                                              specifiedByUrl?: string | null;
                                                                                              specifiedByURL?: string | null;
                                                                                              },
                                                                                              schema?: GraphQLSchema,
                                                                                              pathToDirectivesInExtensions?: Array<string>
                                                                                              ) => Array<TDirectiveNode>;

                                                                                                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 getFieldEntryKey

                                                                                                      getFieldEntryKey: (node: FieldNode) => string;
                                                                                                      • Implements the logic to compute the key of a given field's entry

                                                                                                      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 hasOwnProperty

                                                                                                                        hasOwnProperty: (obj: unknown, prop: string) => boolean;

                                                                                                                          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 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;
                                                                                                                                      • Determines if a given input is a valid GraphQL document string.

                                                                                                                                        Parameter str

                                                                                                                                        The input to validate as a GraphQL document

                                                                                                                                        Returns

                                                                                                                                        A boolean indicating whether the input is a valid GraphQL document string

                                                                                                                                        Throws

                                                                                                                                        {Error} If the document fails to parse and is empty except GraphQL comments

                                                                                                                                        Remarks

                                                                                                                                        This function performs several validation checks: - Ensures the input is a string - Filters out strings with invalid document extensions - Excludes URLs - Attempts to parse the string as a GraphQL document

                                                                                                                                      function isIterableObject

                                                                                                                                      isIterableObject: (value: unknown) => value is Iterable<unknown>;

                                                                                                                                        function isNamedStub

                                                                                                                                        isNamedStub: (type: GraphQLNamedType) => boolean;

                                                                                                                                          function isObjectLike

                                                                                                                                          isObjectLike: (value: unknown) => value is { [key: string]: unknown };

                                                                                                                                            function isSome

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

                                                                                                                                              function isUrl

                                                                                                                                              isUrl: (str: string) => boolean;
                                                                                                                                              • Checks if the given string is a valid URL.

                                                                                                                                                Parameter str

                                                                                                                                                The string to validate as a URL

                                                                                                                                                Returns

                                                                                                                                                A boolean indicating whether the string is a valid URL

                                                                                                                                                Remarks

                                                                                                                                                This function first attempts to use the URL.canParse method if available. If not, it falls back to creating a new URL object to validate the string.

                                                                                                                                              function isValidPath

                                                                                                                                              isValidPath: (str: any) => boolean;
                                                                                                                                              • Checkes whether the str contains any path illegal characters.

                                                                                                                                                A string may sometimes look like a path but is not (like an SDL of a simple GraphQL schema). To make sure we don't yield false-positives in such cases, we disallow new lines in paths (even though most Unix systems support new lines in file names).

                                                                                                                                              function makeDeprecatedDirective

                                                                                                                                              makeDeprecatedDirective: <TDirectiveNode extends DirectiveNode>(
                                                                                                                                              deprecationReason: string
                                                                                                                                              ) => TDirectiveNode;

                                                                                                                                                function makeDirectiveNode

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

                                                                                                                                                  function makeDirectiveNodes

                                                                                                                                                  makeDirectiveNodes: <TDirectiveNode extends DirectiveNode>(
                                                                                                                                                  schema: GraphQLSchema,
                                                                                                                                                  directiveValues: DirectiveAnnotation[]
                                                                                                                                                  ) => Array<TDirectiveNode>;

                                                                                                                                                    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 memoize2of5

                                                                                                                                                            memoize2of5: <F extends (a1: any, a2: any, a3: any, a4: any, a5: 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,
                                                                                                                                                                    respectArrays?: boolean,
                                                                                                                                                                    respectArrayLength?: boolean
                                                                                                                                                                    ) => UnboxIntersection<UnionToIntersection<BoxedTupleTypes<S>>> & any;

                                                                                                                                                                      function mergeIncrementalResult

                                                                                                                                                                      mergeIncrementalResult: ({
                                                                                                                                                                      incrementalResult,
                                                                                                                                                                      executionResult,
                                                                                                                                                                      }: {
                                                                                                                                                                      incrementalResult: ExecutionResult;
                                                                                                                                                                      executionResult: ExecutionResult;
                                                                                                                                                                      }) => void;

                                                                                                                                                                        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 pathToArray

                                                                                                                                                                                        pathToArray: (path: Maybe<Readonly<Path>>) => Array<string | number>;
                                                                                                                                                                                        • Given a Path, return an Array of the path keys.

                                                                                                                                                                                        function printComment

                                                                                                                                                                                        printComment: (comment: string) => string;

                                                                                                                                                                                          function printPathArray

                                                                                                                                                                                          printPathArray: (path: ReadonlyArray<string | number>) => string;
                                                                                                                                                                                          • Build a string describing the path.

                                                                                                                                                                                          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 promiseReduce

                                                                                                                                                                                            promiseReduce: <T, U>(
                                                                                                                                                                                            values: Iterable<T>,
                                                                                                                                                                                            callbackFn: (accumulator: U, currentValue: T) => MaybePromise<U>,
                                                                                                                                                                                            initialValue: MaybePromise<U>
                                                                                                                                                                                            ) => MaybePromise<U>;

                                                                                                                                                                                              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 registerAbortSignalListener

                                                                                                                                                                                                registerAbortSignalListener: (signal: AbortSignal, listener: () => void) => void;
                                                                                                                                                                                                • Register an AbortSignal handler for a signal. This helper function mainly exists to work around the "possible EventEmitter memory leak detected. 11 listeners added. Use emitter.setMaxListeners() to increase limit." warning occuring on Node.js

                                                                                                                                                                                                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 shouldIncludeNode

                                                                                                                                                                                                              shouldIncludeNode: (
                                                                                                                                                                                                              variableValues: any,
                                                                                                                                                                                                              node: FragmentSpreadNode | FieldNode | InlineFragmentNode
                                                                                                                                                                                                              ) => boolean;
                                                                                                                                                                                                              • Determines if a field should be included based on the @include and @skip directives, where @skip has higher precedence than @include.

                                                                                                                                                                                                              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,
                                                                                                                                                                                                                    documents: DocumentNode[],
                                                                                                                                                                                                                    rules?: ValidationRule[]
                                                                                                                                                                                                                    ) => readonly import('graphql').GraphQLError[];

                                                                                                                                                                                                                      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<
                                                                                                                                                                                                                                      TVariables extends Record<string, any> = any,
                                                                                                                                                                                                                                      TContext = any,
                                                                                                                                                                                                                                      TRootValue = any,
                                                                                                                                                                                                                                      TExtensions = Record<string, any>,
                                                                                                                                                                                                                                      TReturn = any
                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                        property context

                                                                                                                                                                                                                                        context?: TContext;

                                                                                                                                                                                                                                          property document

                                                                                                                                                                                                                                          document: TypedDocumentNode<TReturn, TVariables>;

                                                                                                                                                                                                                                            property extensions

                                                                                                                                                                                                                                            extensions?: TExtensions;

                                                                                                                                                                                                                                              property info

                                                                                                                                                                                                                                              info?: GraphQLResolveInfo;

                                                                                                                                                                                                                                                property operationName

                                                                                                                                                                                                                                                operationName?: string;

                                                                                                                                                                                                                                                  property operationType

                                                                                                                                                                                                                                                  operationType?: OperationTypeNode;

                                                                                                                                                                                                                                                    property rootValue

                                                                                                                                                                                                                                                    rootValue?: TRootValue;

                                                                                                                                                                                                                                                      property signal

                                                                                                                                                                                                                                                      signal?: AbortSignal;

                                                                                                                                                                                                                                                        property variables

                                                                                                                                                                                                                                                        variables?: TVariables;

                                                                                                                                                                                                                                                          interface ExecutionResult

                                                                                                                                                                                                                                                          interface ExecutionResult<TData = any, TExtensions = any> {}
                                                                                                                                                                                                                                                          • The result of GraphQL execution.

                                                                                                                                                                                                                                                            - errors is included when any errors occurred as a non-empty array. - data is the result of a successful execution of the query. - hasNext is true if a future payload is expected. - extensions is reserved for adding non-standard properties.

                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                          data?: TData | null;

                                                                                                                                                                                                                                                            property errors

                                                                                                                                                                                                                                                            errors?: ReadonlyArray<GraphQLError>;

                                                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                                                              extensions?: TExtensions;

                                                                                                                                                                                                                                                                property hasNext

                                                                                                                                                                                                                                                                hasNext?: boolean;

                                                                                                                                                                                                                                                                  property incremental

                                                                                                                                                                                                                                                                  incremental?: ReadonlyArray<ExecutionResult<TData, TExtensions>>;

                                                                                                                                                                                                                                                                    property items

                                                                                                                                                                                                                                                                    items?: TData | null;

                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                      label?: string;

                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                        path?: ReadonlyArray<string | number>;

                                                                                                                                                                                                                                                                          interface FieldsAndPatches

                                                                                                                                                                                                                                                                          interface FieldsAndPatches {}

                                                                                                                                                                                                                                                                            property fields

                                                                                                                                                                                                                                                                            fields: Map<string, Array<FieldNode>>;

                                                                                                                                                                                                                                                                              property patches

                                                                                                                                                                                                                                                                              patches: Array<PatchFields>;

                                                                                                                                                                                                                                                                                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 GraphQLResolveInfo

                                                                                                                                                                                                                                                                                              interface GraphQLResolveInfo extends OrigGraphQLResolveInfo {}

                                                                                                                                                                                                                                                                                                property signal

                                                                                                                                                                                                                                                                                                signal?: AbortSignal;

                                                                                                                                                                                                                                                                                                  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 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 PatchFields

                                                                                                                                                                                                                                                                                                                                          interface PatchFields {}

                                                                                                                                                                                                                                                                                                                                            property fields

                                                                                                                                                                                                                                                                                                                                            fields: Map<string, Array<FieldNode>>;

                                                                                                                                                                                                                                                                                                                                              property label

                                                                                                                                                                                                                                                                                                                                              label: string | undefined;

                                                                                                                                                                                                                                                                                                                                                interface Path

                                                                                                                                                                                                                                                                                                                                                interface Path {}

                                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                                  readonly key: string | number;

                                                                                                                                                                                                                                                                                                                                                    property prev

                                                                                                                                                                                                                                                                                                                                                    readonly prev: Path | undefined;

                                                                                                                                                                                                                                                                                                                                                      property typename

                                                                                                                                                                                                                                                                                                                                                      readonly typename: string | undefined;

                                                                                                                                                                                                                                                                                                                                                        interface PromiseWithResolvers

                                                                                                                                                                                                                                                                                                                                                        interface PromiseWithResolvers<T> {}

                                                                                                                                                                                                                                                                                                                                                          property promise

                                                                                                                                                                                                                                                                                                                                                          promise: Promise<T>;

                                                                                                                                                                                                                                                                                                                                                            property reject

                                                                                                                                                                                                                                                                                                                                                            reject: (reason?: any) => void;

                                                                                                                                                                                                                                                                                                                                                              property resolve

                                                                                                                                                                                                                                                                                                                                                              resolve: (value: T | PromiseLike<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 ArgumentToDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ArgumentToDirectives = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [argumentName: string]: DirectiveUsage[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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, TReturn>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<MaybeAsyncIterable<ExecutionResult<TReturn>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BaseLoaderOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 DirectableASTNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DirectableASTNode = ASTNode & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              directives?: readonly DirectiveNode[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DirectableGraphQLObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DirectableGraphQLObject = DirectableObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DirectableObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DirectableObject = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  astNode?: DirectableASTNode | null | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extensionASTNodes?: readonly DirectableASTNode[] | null | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extensions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DirectiveArgs

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DirectiveFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DirectiveFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      directiveName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      directive: GraphQLDirective
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 DisposableAsyncExecutor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DisposableAsyncExecutor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = AsyncExecutor<TBaseContext, TBaseExtensions> & AsyncDisposable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DisposableExecutor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DisposableExecutor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | DisposableSyncExecutor<TBaseContext, TBaseExtensions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | DisposableAsyncExecutor<TBaseContext, TBaseExtensions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DisposableSyncExecutor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DisposableSyncExecutor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TBaseContext = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TBaseExtensions = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > = SyncExecutor<TBaseContext, TBaseExtensions> & Disposable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ElementOf

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnumTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnumTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'enum';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      values: Record<string, ExtensionsObject>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnumTypeMapper

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnumValueFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnumValueFilter = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typeName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          valueName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          valueConfig: GraphQLEnumValueConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 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, TReturn>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => MaybePromise<MaybeAsyncIterable<ExecutionResult<TReturn>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExtensionsObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExtensionsObject = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 InputTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'input';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fields: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extensions: ExtensionsObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InterfaceTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InterfaceTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'interface';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fields: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions: ExtensionsObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arguments: Record<string, ExtensionsObject>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 MaybeAsyncIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeAsyncIterable<T> = AsyncIterable<T> | 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 ObjectTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'object';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fields: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extensions: ExtensionsObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arguments: Record<string, ExtensionsObject>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ObjectTypeMapper

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ObjectValueVisitor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossibleTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossibleTypeExtensions =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InputTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InterfaceTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ObjectTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | UnionTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ScalarTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | EnumTypeExtensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 ScalarTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ScalarTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'scalar';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ScalarTypeMapper

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            schemaExtensions: ExtensionsObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            types: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions: ExtensionsObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } & PossibleTypeExtensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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, TReturn>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ExecutionResult<TReturn>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TypeAndFieldToArgumentDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TypeAndFieldToArgumentDirectives = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [typeAndField: string]: ArgumentToDirectives;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 UnionTypeExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnionTypeExtensions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'union';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 (57)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (5)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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>