@graphql-codegen/visitor-plugin-common

  • Version 2.12.1
  • Published
  • 455 kB
  • 10 dependencies
  • MIT license

Install

npm i @graphql-codegen/visitor-plugin-common
yarn add @graphql-codegen/visitor-plugin-common
pnpm add @graphql-codegen/visitor-plugin-common

Overview

Overview not available.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable DEFAULT_AVOID_OPTIONALS

const DEFAULT_AVOID_OPTIONALS: AvoidOptionalsConfig;

    variable DEFAULT_DECLARATION_KINDS

    const DEFAULT_DECLARATION_KINDS: DeclarationKindConfig;

      variable DEFAULT_SCALARS

      const DEFAULT_SCALARS: NormalizedScalarsMap;

        variable OMIT_TYPE

        const OMIT_TYPE: string;

          variable REQUIRE_FIELDS_TYPE

          const REQUIRE_FIELDS_TYPE: string;

            Functions

            function block

            block: (array: any) => string;

              function breakLine

              breakLine: (str: string) => string;

                function buildMapperImport

                buildMapperImport: (
                source: string,
                types: { identifier: string; asDefault?: boolean }[],
                useTypeImports: boolean
                ) => string | null;

                  function buildScalars

                  buildScalars: (
                  schema: GraphQLSchema | undefined,
                  scalarsMapping: ScalarsMap,
                  defaultScalarsMapping?: NormalizedScalarsMap,
                  defaultScalarType?: string | null
                  ) => ParsedScalarsMap;

                    function buildScalarsFromConfig

                    buildScalarsFromConfig: (
                    schema: GraphQLSchema | undefined,
                    config: RawConfig,
                    defaultScalarsMapping?: NormalizedScalarsMap,
                    defaultScalarType?: string
                    ) => ParsedScalarsMap;

                      function clearExtension

                      clearExtension: (path: string) => string;

                        function convertFactory

                        convertFactory: (config: { namingConvention?: NamingConvention }) => ConvertFn;

                          function convertNameParts

                          convertNameParts: (
                          str: string,
                          func: (str: string) => string,
                          removeUnderscore?: boolean
                          ) => string;

                            function fixLocalFilePath

                            fixLocalFilePath: (path: string) => string;

                              function generateFragmentImportStatement

                              generateFragmentImportStatement: (
                              statement: ImportDeclaration<FragmentImport>,
                              kind: 'type' | 'document' | 'both'
                              ) => string;

                                function generateImportStatement

                                generateImportStatement: (statement: ImportDeclaration) => string;

                                  function getBaseTypeNode

                                  getBaseTypeNode: (typeNode: TypeNode) => NamedTypeNode;

                                    function getConfigValue

                                    getConfigValue: <T = any>(value: T, defaultValue: T) => T;

                                      function getFieldNodeNameValue

                                      getFieldNodeNameValue: (node: FieldNode) => string;

                                        function getPossibleTypes

                                        getPossibleTypes: (
                                        schema: GraphQLSchema,
                                        type: GraphQLNamedType
                                        ) => GraphQLObjectType[];

                                          function getRootTypeNames

                                          getRootTypeNames: (schema: GraphQLSchema) => string[];

                                            function hasConditionalDirectives

                                            hasConditionalDirectives: (field: FieldNode) => boolean;

                                              function indent

                                              indent: (str: string, count?: number) => string;

                                                function indentMultiline

                                                indentMultiline: (str: string, count?: number) => string;

                                                  function isExternalMapper

                                                  isExternalMapper: (value: string) => boolean;

                                                    function isExternalMapperType

                                                    isExternalMapperType: (m: ParsedMapper) => m is ExternalParsedMapper;

                                                      function isOneOfInputObjectType

                                                      isOneOfInputObjectType: (
                                                      namedType: GraphQLNamedType | null | undefined
                                                      ) => namedType is GraphQLInputObjectType;

                                                        function mergeSelectionSets

                                                        mergeSelectionSets: (
                                                        selectionSet1: SelectionSetNode,
                                                        selectionSet2: SelectionSetNode
                                                        ) => SelectionSetNode;
                                                        • merge selection sets into a new selection set without mutating the inputs.

                                                        function normalizeAvoidOptionals

                                                        normalizeAvoidOptionals: (
                                                        avoidOptionals?: boolean | AvoidOptionalsConfig
                                                        ) => AvoidOptionalsConfig;

                                                          function normalizeDeclarationKind

                                                          normalizeDeclarationKind: (
                                                          declarationKind?: DeclarationKind | DeclarationKindConfig
                                                          ) => DeclarationKindConfig;

                                                            function optimizeOperations

                                                            optimizeOperations: (
                                                            schema: GraphQLSchema,
                                                            documents: Types.DocumentFile[],
                                                            options?: { includeFragments: boolean }
                                                            ) => Types.DocumentFile[];

                                                              function parseEnumValues

                                                              parseEnumValues: ({
                                                              schema,
                                                              mapOrStr,
                                                              ignoreEnumValuesFromSchema,
                                                              }: {
                                                              schema: GraphQLSchema;
                                                              mapOrStr: EnumValuesMap;
                                                              ignoreEnumValuesFromSchema?: boolean;
                                                              }) => ParsedEnumValuesMap;

                                                                function parseMapper

                                                                parseMapper: (
                                                                mapper: string,
                                                                gqlTypeName?: string | null,
                                                                suffix?: string
                                                                ) => ParsedMapper;

                                                                  function quoteIfNeeded

                                                                  quoteIfNeeded: (array: string[], joinWith?: string) => string;

                                                                    function removeDescription

                                                                    removeDescription: <T extends { description?: StringValueNode }>(
                                                                    nodes: readonly T[]
                                                                    ) => (T & { description: any })[];

                                                                      function resolveImportSource

                                                                      resolveImportSource: <T>(source: string | ImportSource<T>) => ImportSource<T>;

                                                                        function resolveRelativeImport

                                                                        resolveRelativeImport: (from: string, to: string) => string;

                                                                          function separateSelectionSet

                                                                          separateSelectionSet: (selections: ReadonlyArray<SelectionNode>) => {
                                                                          fields: FieldNode[];
                                                                          spreads: FragmentSpreadNode[];
                                                                          inlines: InlineFragmentNode[];
                                                                          };

                                                                            function stripMapperTypeInterpolation

                                                                            stripMapperTypeInterpolation: (identifier: string) => string;

                                                                              function transformComment

                                                                              transformComment: (
                                                                              comment: string | StringValueNode,
                                                                              indentLevel?: number,
                                                                              disabled?: boolean
                                                                              ) => string;

                                                                                function transformDirectiveArgumentAndInputFieldMappings

                                                                                transformDirectiveArgumentAndInputFieldMappings: (
                                                                                rawDirectiveArgumentAndInputFieldMappings: DirectiveArgumentAndInputFieldMappings,
                                                                                directiveArgumentAndInputFieldMappingTypeSuffix?: string
                                                                                ) => ParsedDirectiveArgumentAndInputFieldMappings;

                                                                                  function transformMappers

                                                                                  transformMappers: (
                                                                                  rawMappers: RawResolversConfig['mappers'],
                                                                                  mapperTypeSuffix?: string
                                                                                  ) => ParsedResolversConfig['mappers'];

                                                                                    function wrapTypeNodeWithModifiers

                                                                                    wrapTypeNodeWithModifiers: (baseType: string, typeNode: TypeNode) => string;

                                                                                      function wrapTypeWithModifiers

                                                                                      wrapTypeWithModifiers: (
                                                                                      baseType: string,
                                                                                      type: GraphQLOutputType | GraphQLNamedType,
                                                                                      options: WrapModifiersOptions
                                                                                      ) => string;

                                                                                        function wrapWithSingleQuotes

                                                                                        wrapWithSingleQuotes: (
                                                                                        value: string | number | NameNode,
                                                                                        skipNumericCheck?: boolean
                                                                                        ) => string;

                                                                                          Classes

                                                                                          class BaseDocumentsVisitor

                                                                                          class BaseDocumentsVisitor<
                                                                                          TRawConfig extends RawDocumentsConfig = RawDocumentsConfig,
                                                                                          TPluginConfig extends ParsedDocumentsConfig = ParsedDocumentsConfig
                                                                                          > extends BaseVisitor<TRawConfig, TPluginConfig> {}

                                                                                            constructor

                                                                                            constructor(
                                                                                            rawConfig: RawDocumentsConfig,
                                                                                            additionalConfig: ParsedDocumentsConfig,
                                                                                            _schema: GraphQLSchema,
                                                                                            defaultScalars?: NormalizedScalarsMap
                                                                                            );

                                                                                              property addTypename

                                                                                              readonly addTypename: boolean;

                                                                                                property schema

                                                                                                readonly schema: GraphQLSchema;

                                                                                                  method applyVariablesWrapper

                                                                                                  protected applyVariablesWrapper: (variablesBlock: string) => string;

                                                                                                    method FragmentDefinition

                                                                                                    FragmentDefinition: (node: FragmentDefinitionNode) => string;

                                                                                                      method getGlobalDeclarations

                                                                                                      getGlobalDeclarations: (noExport?: boolean) => string[];

                                                                                                        method OperationDefinition

                                                                                                        OperationDefinition: (node: OperationDefinitionNode) => string;

                                                                                                          method setDeclarationBlockConfig

                                                                                                          setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

                                                                                                            method setSelectionSetHandler

                                                                                                            setSelectionSetHandler: (handler: SelectionSetToObject) => void;

                                                                                                              method setVariablesTransformer

                                                                                                              setVariablesTransformer: (
                                                                                                              variablesTransfomer: OperationVariablesToObject
                                                                                                              ) => void;

                                                                                                                class BaseResolversVisitor

                                                                                                                class BaseResolversVisitor<
                                                                                                                TRawConfig extends RawResolversConfig = RawResolversConfig,
                                                                                                                TPluginConfig extends ParsedResolversConfig = ParsedResolversConfig
                                                                                                                > extends BaseVisitor<TRawConfig, TPluginConfig> {}

                                                                                                                  constructor

                                                                                                                  constructor(
                                                                                                                  rawConfig: RawResolversConfig,
                                                                                                                  additionalConfig: ParsedResolversConfig,
                                                                                                                  _schema: GraphQLSchema,
                                                                                                                  defaultScalars?: NormalizedScalarsMap
                                                                                                                  );

                                                                                                                    property defaultMapperType

                                                                                                                    readonly defaultMapperType: string;

                                                                                                                      property globalDeclarations

                                                                                                                      readonly globalDeclarations: string[];

                                                                                                                        property mappersImports

                                                                                                                        readonly mappersImports: string[];

                                                                                                                          property schema

                                                                                                                          readonly schema: GraphQLSchema;

                                                                                                                            property unusedMappers

                                                                                                                            readonly unusedMappers: string[];

                                                                                                                              method applyMaybe

                                                                                                                              protected applyMaybe: (str: string) => string;

                                                                                                                                method applyOptionalFields

                                                                                                                                protected applyOptionalFields: (
                                                                                                                                argsType: string,
                                                                                                                                _fields: readonly InputValueDefinitionNode[]
                                                                                                                                ) => string;

                                                                                                                                  method applyRequireFields

                                                                                                                                  protected applyRequireFields: (
                                                                                                                                  argsType: string,
                                                                                                                                  fields: InputValueDefinitionNode[]
                                                                                                                                  ) => string;

                                                                                                                                    method applyResolverTypeWrapper

                                                                                                                                    protected applyResolverTypeWrapper: (str: string) => string;

                                                                                                                                      method buildEnumResolverContentBlock

                                                                                                                                      protected buildEnumResolverContentBlock: (
                                                                                                                                      _node: EnumTypeDefinitionNode,
                                                                                                                                      _mappedEnumType: string
                                                                                                                                      ) => string;

                                                                                                                                        method buildEnumResolversExplicitMappedValues

                                                                                                                                        protected buildEnumResolversExplicitMappedValues: (
                                                                                                                                        _node: EnumTypeDefinitionNode,
                                                                                                                                        _valuesMapping: { [valueName: string]: string | number }
                                                                                                                                        ) => string;

                                                                                                                                          method buildResolversParentTypes

                                                                                                                                          buildResolversParentTypes: () => string;

                                                                                                                                            method buildResolversTypes

                                                                                                                                            buildResolversTypes: () => string;

                                                                                                                                              method clearMaybe

                                                                                                                                              protected clearMaybe: (str: string) => string;

                                                                                                                                                method clearResolverTypeWrapper

                                                                                                                                                protected clearResolverTypeWrapper: (str: string) => string;

                                                                                                                                                  method convertName

                                                                                                                                                  convertName: (
                                                                                                                                                  node: ASTNode | string,
                                                                                                                                                  options?: BaseVisitorConvertOptions & ConvertOptions,
                                                                                                                                                  applyNamespacedImport?: boolean
                                                                                                                                                  ) => string;

                                                                                                                                                    method createDirectivedContextType

                                                                                                                                                    protected createDirectivedContextType: () => FieldContextTypeMap;

                                                                                                                                                      method createFieldContextTypeMap

                                                                                                                                                      protected createFieldContextTypeMap: () => FieldContextTypeMap;

                                                                                                                                                        method createResolversFields

                                                                                                                                                        protected createResolversFields: (
                                                                                                                                                        applyWrapper: (str: string) => string,
                                                                                                                                                        clearWrapper: (str: string) => string,
                                                                                                                                                        getTypeToUse: (str: string) => string,
                                                                                                                                                        shouldInclude?: (type: GraphQLNamedType) => boolean
                                                                                                                                                        ) => ResolverTypes;

                                                                                                                                                          method DirectiveDefinition

                                                                                                                                                          DirectiveDefinition: (
                                                                                                                                                          node: DirectiveDefinitionNode,
                                                                                                                                                          key: string | number,
                                                                                                                                                          parent: any
                                                                                                                                                          ) => string;

                                                                                                                                                            method EnumTypeDefinition

                                                                                                                                                            EnumTypeDefinition: (node: EnumTypeDefinitionNode) => string;

                                                                                                                                                              method FieldDefinition

                                                                                                                                                              FieldDefinition: (
                                                                                                                                                              node: FieldDefinitionNode,
                                                                                                                                                              key: string | number,
                                                                                                                                                              parent: any
                                                                                                                                                              ) => (parentName: string) => string | null;

                                                                                                                                                                method formatRootResolver

                                                                                                                                                                protected formatRootResolver: (
                                                                                                                                                                schemaTypeName: string,
                                                                                                                                                                resolverType: string,
                                                                                                                                                                declarationKind: DeclarationKind
                                                                                                                                                                ) => string;

                                                                                                                                                                  method getAllDirectiveResolvers

                                                                                                                                                                  getAllDirectiveResolvers: () => string;

                                                                                                                                                                    method getParentTypeForSignature

                                                                                                                                                                    protected getParentTypeForSignature: (_node: FieldDefinitionNode) => string;

                                                                                                                                                                      method getParentTypeToUse

                                                                                                                                                                      protected getParentTypeToUse: (name: string) => string;

                                                                                                                                                                        method getResolverTypeWrapperSignature

                                                                                                                                                                        getResolverTypeWrapperSignature: () => string;

                                                                                                                                                                          method getRootResolver

                                                                                                                                                                          getRootResolver: () => string;

                                                                                                                                                                            method getTypeToUse

                                                                                                                                                                            protected getTypeToUse: (name: string) => string;

                                                                                                                                                                              method hasFederation

                                                                                                                                                                              hasFederation: () => boolean;

                                                                                                                                                                                method hasScalars

                                                                                                                                                                                hasScalars: () => boolean;

                                                                                                                                                                                  method InterfaceTypeDefinition

                                                                                                                                                                                  InterfaceTypeDefinition: (node: InterfaceTypeDefinitionNode) => string;

                                                                                                                                                                                    method isMapperImported

                                                                                                                                                                                    protected isMapperImported: (
                                                                                                                                                                                    groupedMappers: GroupedMappers,
                                                                                                                                                                                    identifier: string,
                                                                                                                                                                                    source: string
                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                      method ListType

                                                                                                                                                                                      ListType: (node: ListTypeNode) => string;

                                                                                                                                                                                        method markMapperAsUsed

                                                                                                                                                                                        protected markMapperAsUsed: (name: string) => void;

                                                                                                                                                                                          method Name

                                                                                                                                                                                          Name: (node: NameNode) => string;

                                                                                                                                                                                            method NamedType

                                                                                                                                                                                            NamedType: (node: NamedTypeNode) => string;

                                                                                                                                                                                              method NonNullType

                                                                                                                                                                                              NonNullType: (node: NonNullTypeNode) => string;

                                                                                                                                                                                                method ObjectTypeDefinition

                                                                                                                                                                                                ObjectTypeDefinition: (node: ObjectTypeDefinitionNode) => string;

                                                                                                                                                                                                  method replaceFieldsInType

                                                                                                                                                                                                  protected replaceFieldsInType: (
                                                                                                                                                                                                  typeName: string,
                                                                                                                                                                                                  relevantFields: {
                                                                                                                                                                                                  addOptionalSign: boolean;
                                                                                                                                                                                                  fieldName: string;
                                                                                                                                                                                                  replaceWithType: string;
                                                                                                                                                                                                  }[]
                                                                                                                                                                                                  ) => string;

                                                                                                                                                                                                    method ScalarTypeDefinition

                                                                                                                                                                                                    ScalarTypeDefinition: (node: ScalarTypeDefinitionNode) => string;

                                                                                                                                                                                                      method SchemaDefinition

                                                                                                                                                                                                      SchemaDefinition: () => any;

                                                                                                                                                                                                        method setDeclarationBlockConfig

                                                                                                                                                                                                        setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

                                                                                                                                                                                                          method setVariablesTransformer

                                                                                                                                                                                                          setVariablesTransformer: (
                                                                                                                                                                                                          variablesTransfomer: OperationVariablesToObject
                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                            method shouldMapType

                                                                                                                                                                                                            protected shouldMapType: (
                                                                                                                                                                                                            type: GraphQLNamedType,
                                                                                                                                                                                                            duringCheck?: string[]
                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                              method transformParentGenericType

                                                                                                                                                                                                              protected transformParentGenericType: (parentType: string) => string;

                                                                                                                                                                                                                method UnionTypeDefinition

                                                                                                                                                                                                                UnionTypeDefinition: (
                                                                                                                                                                                                                node: UnionTypeDefinitionNode,
                                                                                                                                                                                                                key: string | number,
                                                                                                                                                                                                                parent: any
                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                  method wrapWithArray

                                                                                                                                                                                                                  protected wrapWithArray: (t: string) => string;

                                                                                                                                                                                                                    class BaseSelectionSetProcessor

                                                                                                                                                                                                                    class BaseSelectionSetProcessor<Config extends SelectionSetProcessorConfig> {}

                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                      constructor(config: SelectionSetProcessorConfig);

                                                                                                                                                                                                                        property config

                                                                                                                                                                                                                        config: SelectionSetProcessorConfig;

                                                                                                                                                                                                                          method buildFieldsIntoObject

                                                                                                                                                                                                                          buildFieldsIntoObject: (allObjectsMerged: string[]) => string;

                                                                                                                                                                                                                            method buildSelectionSetFromStrings

                                                                                                                                                                                                                            buildSelectionSetFromStrings: (pieces: string[]) => string;

                                                                                                                                                                                                                              method transformAliasesPrimitiveFields

                                                                                                                                                                                                                              transformAliasesPrimitiveFields: (
                                                                                                                                                                                                                              _schemaType: GraphQLObjectType | GraphQLInterfaceType,
                                                                                                                                                                                                                              _fields: PrimitiveAliasedFields[]
                                                                                                                                                                                                                              ) => (string | NameAndType)[];

                                                                                                                                                                                                                                method transformLinkFields

                                                                                                                                                                                                                                transformLinkFields: (_fields: LinkField[]) => (string | NameAndType)[];

                                                                                                                                                                                                                                  method transformPrimitiveFields

                                                                                                                                                                                                                                  transformPrimitiveFields: (
                                                                                                                                                                                                                                  _schemaType: GraphQLObjectType | GraphQLInterfaceType,
                                                                                                                                                                                                                                  _fields: PrimitiveField[]
                                                                                                                                                                                                                                  ) => (string | NameAndType)[];

                                                                                                                                                                                                                                    method transformTypenameField

                                                                                                                                                                                                                                    transformTypenameField: (
                                                                                                                                                                                                                                    _type: string,
                                                                                                                                                                                                                                    _name: string
                                                                                                                                                                                                                                    ) => (string | NameAndType)[];

                                                                                                                                                                                                                                      class BaseTypesVisitor

                                                                                                                                                                                                                                      class BaseTypesVisitor<
                                                                                                                                                                                                                                      TRawConfig extends RawTypesConfig = RawTypesConfig,
                                                                                                                                                                                                                                      TPluginConfig extends ParsedTypesConfig = ParsedTypesConfig
                                                                                                                                                                                                                                      > extends BaseVisitor<TRawConfig, TPluginConfig> {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                        _schema: GraphQLSchema,
                                                                                                                                                                                                                                        rawConfig: RawTypesConfig,
                                                                                                                                                                                                                                        additionalConfig: ParsedTypesConfig,
                                                                                                                                                                                                                                        defaultScalars?: NormalizedScalarsMap
                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                          property directiveArgumentAndInputFieldMappingsDefinition

                                                                                                                                                                                                                                          readonly directiveArgumentAndInputFieldMappingsDefinition: string;

                                                                                                                                                                                                                                            property scalarsDefinition

                                                                                                                                                                                                                                            readonly scalarsDefinition: string;

                                                                                                                                                                                                                                              method appendInterfacesAndFieldsToBlock

                                                                                                                                                                                                                                              appendInterfacesAndFieldsToBlock: (
                                                                                                                                                                                                                                              block: DeclarationBlock,
                                                                                                                                                                                                                                              interfaces: string[],
                                                                                                                                                                                                                                              fields: string[]
                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                method buildArgumentsBlock

                                                                                                                                                                                                                                                protected buildArgumentsBlock: (
                                                                                                                                                                                                                                                node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode
                                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                                  method buildEnumValuesBlock

                                                                                                                                                                                                                                                  protected buildEnumValuesBlock: (
                                                                                                                                                                                                                                                  typeName: string,
                                                                                                                                                                                                                                                  values: ReadonlyArray<EnumValueDefinitionNode>
                                                                                                                                                                                                                                                  ) => string;

                                                                                                                                                                                                                                                    method DirectiveDefinition

                                                                                                                                                                                                                                                    DirectiveDefinition: (_node: DirectiveDefinitionNode) => string;

                                                                                                                                                                                                                                                      method EnumTypeDefinition

                                                                                                                                                                                                                                                      EnumTypeDefinition: (node: EnumTypeDefinitionNode) => string;

                                                                                                                                                                                                                                                        method FieldDefinition

                                                                                                                                                                                                                                                        FieldDefinition: (node: FieldDefinitionNode) => string;

                                                                                                                                                                                                                                                          method getArgumentsObjectDeclarationBlock

                                                                                                                                                                                                                                                          getArgumentsObjectDeclarationBlock: (
                                                                                                                                                                                                                                                          node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode,
                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                          field: FieldDefinitionNode
                                                                                                                                                                                                                                                          ) => DeclarationBlock;

                                                                                                                                                                                                                                                            method getArgumentsObjectTypeDefinition

                                                                                                                                                                                                                                                            getArgumentsObjectTypeDefinition: (
                                                                                                                                                                                                                                                            node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode,
                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                            field: FieldDefinitionNode
                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                              method getDeprecationReason

                                                                                                                                                                                                                                                              protected getDeprecationReason: (directive: DirectiveNode) => string | void;

                                                                                                                                                                                                                                                                method getDirectiveArgumentAndInputFieldMappingsImports

                                                                                                                                                                                                                                                                getDirectiveArgumentAndInputFieldMappingsImports: () => string[];

                                                                                                                                                                                                                                                                  method getEntireFieldWrapperValue

                                                                                                                                                                                                                                                                  getEntireFieldWrapperValue: () => string;

                                                                                                                                                                                                                                                                    method getEnumsImports

                                                                                                                                                                                                                                                                    getEnumsImports: () => string[];

                                                                                                                                                                                                                                                                      method getExportPrefix

                                                                                                                                                                                                                                                                      protected getExportPrefix: () => string;

                                                                                                                                                                                                                                                                        method getFieldWrapperValue

                                                                                                                                                                                                                                                                        getFieldWrapperValue: () => string;

                                                                                                                                                                                                                                                                          method getInputObjectDeclarationBlock

                                                                                                                                                                                                                                                                          getInputObjectDeclarationBlock: (
                                                                                                                                                                                                                                                                          node: InputObjectTypeDefinitionNode
                                                                                                                                                                                                                                                                          ) => DeclarationBlock;

                                                                                                                                                                                                                                                                            method getInputObjectOneOfDeclarationBlock

                                                                                                                                                                                                                                                                            getInputObjectOneOfDeclarationBlock: (
                                                                                                                                                                                                                                                                            node: InputObjectTypeDefinitionNode
                                                                                                                                                                                                                                                                            ) => DeclarationBlock;

                                                                                                                                                                                                                                                                              method getInterfaceTypeDeclarationBlock

                                                                                                                                                                                                                                                                              getInterfaceTypeDeclarationBlock: (
                                                                                                                                                                                                                                                                              node: InterfaceTypeDefinitionNode,
                                                                                                                                                                                                                                                                              _originalNode: InterfaceTypeDefinitionNode
                                                                                                                                                                                                                                                                              ) => DeclarationBlock;

                                                                                                                                                                                                                                                                                method getNodeComment

                                                                                                                                                                                                                                                                                getNodeComment: (
                                                                                                                                                                                                                                                                                node:
                                                                                                                                                                                                                                                                                | FieldDefinitionNode
                                                                                                                                                                                                                                                                                | EnumValueDefinitionNode
                                                                                                                                                                                                                                                                                | InputValueDefinitionNode
                                                                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                                                                  method getObjectTypeDeclarationBlock

                                                                                                                                                                                                                                                                                  getObjectTypeDeclarationBlock: (
                                                                                                                                                                                                                                                                                  node: ObjectTypeDefinitionNode,
                                                                                                                                                                                                                                                                                  originalNode: ObjectTypeDefinitionNode
                                                                                                                                                                                                                                                                                  ) => DeclarationBlock;

                                                                                                                                                                                                                                                                                    method getScalarsImports

                                                                                                                                                                                                                                                                                    getScalarsImports: () => string[];

                                                                                                                                                                                                                                                                                      method handleEnumValueMapper

                                                                                                                                                                                                                                                                                      protected handleEnumValueMapper: (
                                                                                                                                                                                                                                                                                      typeIdentifier: string,
                                                                                                                                                                                                                                                                                      importIdentifier: string | null,
                                                                                                                                                                                                                                                                                      sourceIdentifier: string | null,
                                                                                                                                                                                                                                                                                      sourceFile: string | null
                                                                                                                                                                                                                                                                                      ) => string[];

                                                                                                                                                                                                                                                                                        method InputObjectTypeDefinition

                                                                                                                                                                                                                                                                                        InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => string;

                                                                                                                                                                                                                                                                                          method InputValueDefinition

                                                                                                                                                                                                                                                                                          InputValueDefinition: (node: InputValueDefinitionNode) => string;

                                                                                                                                                                                                                                                                                            method InterfaceTypeDefinition

                                                                                                                                                                                                                                                                                            InterfaceTypeDefinition: (
                                                                                                                                                                                                                                                                                            node: InterfaceTypeDefinitionNode,
                                                                                                                                                                                                                                                                                            key: number | string,
                                                                                                                                                                                                                                                                                            parent: any
                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                              method ListType

                                                                                                                                                                                                                                                                                              ListType: (
                                                                                                                                                                                                                                                                                              node: ListTypeNode,
                                                                                                                                                                                                                                                                                              key: any,
                                                                                                                                                                                                                                                                                              parent: any,
                                                                                                                                                                                                                                                                                              path: any,
                                                                                                                                                                                                                                                                                              ancestors: any
                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                method makeValidEnumIdentifier

                                                                                                                                                                                                                                                                                                protected makeValidEnumIdentifier: (identifier: string) => string;

                                                                                                                                                                                                                                                                                                  method mergeAllFields

                                                                                                                                                                                                                                                                                                  protected mergeAllFields: (
                                                                                                                                                                                                                                                                                                  allFields: string[],
                                                                                                                                                                                                                                                                                                  _hasInterfaces: boolean
                                                                                                                                                                                                                                                                                                  ) => string;

                                                                                                                                                                                                                                                                                                    method mergeInterfaces

                                                                                                                                                                                                                                                                                                    protected mergeInterfaces: (
                                                                                                                                                                                                                                                                                                    interfaces: string[],
                                                                                                                                                                                                                                                                                                    hasOtherFields: boolean
                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                      method Name

                                                                                                                                                                                                                                                                                                      Name: (node: NameNode) => string;

                                                                                                                                                                                                                                                                                                        method NamedType

                                                                                                                                                                                                                                                                                                        NamedType: (
                                                                                                                                                                                                                                                                                                        node: NamedTypeNode,
                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                        parent: any,
                                                                                                                                                                                                                                                                                                        path: any,
                                                                                                                                                                                                                                                                                                        ancestors: any
                                                                                                                                                                                                                                                                                                        ) => string;

                                                                                                                                                                                                                                                                                                          method NonNullType

                                                                                                                                                                                                                                                                                                          NonNullType: (node: NonNullTypeNode) => string;

                                                                                                                                                                                                                                                                                                            method ObjectTypeDefinition

                                                                                                                                                                                                                                                                                                            ObjectTypeDefinition: (
                                                                                                                                                                                                                                                                                                            node: ObjectTypeDefinitionNode,
                                                                                                                                                                                                                                                                                                            key: number | string,
                                                                                                                                                                                                                                                                                                            parent: any
                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                              method ScalarTypeDefinition

                                                                                                                                                                                                                                                                                                              ScalarTypeDefinition: (_node: ScalarTypeDefinitionNode) => string;

                                                                                                                                                                                                                                                                                                                method SchemaDefinition

                                                                                                                                                                                                                                                                                                                SchemaDefinition: () => any;

                                                                                                                                                                                                                                                                                                                  method setArgumentsTransformer

                                                                                                                                                                                                                                                                                                                  setArgumentsTransformer: (
                                                                                                                                                                                                                                                                                                                  argumentsTransfomer: OperationVariablesToObject
                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                    method setDeclarationBlockConfig

                                                                                                                                                                                                                                                                                                                    setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

                                                                                                                                                                                                                                                                                                                      method StringValue

                                                                                                                                                                                                                                                                                                                      StringValue: (node: StringValueNode) => string;

                                                                                                                                                                                                                                                                                                                        method UnionTypeDefinition

                                                                                                                                                                                                                                                                                                                        UnionTypeDefinition: (
                                                                                                                                                                                                                                                                                                                        node: UnionTypeDefinitionNode,
                                                                                                                                                                                                                                                                                                                        key: string | number | undefined,
                                                                                                                                                                                                                                                                                                                        parent: any
                                                                                                                                                                                                                                                                                                                        ) => string;

                                                                                                                                                                                                                                                                                                                          method wrapWithListType

                                                                                                                                                                                                                                                                                                                          protected wrapWithListType: (str: string) => string;

                                                                                                                                                                                                                                                                                                                            class BaseVisitor

                                                                                                                                                                                                                                                                                                                            class BaseVisitor<
                                                                                                                                                                                                                                                                                                                            TRawConfig extends RawConfig = RawConfig,
                                                                                                                                                                                                                                                                                                                            TPluginConfig extends ParsedConfig = ParsedConfig
                                                                                                                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                              constructor(rawConfig: RawConfig, additionalConfig: Partial<TPluginConfig>);

                                                                                                                                                                                                                                                                                                                                property config

                                                                                                                                                                                                                                                                                                                                readonly config: ParsedConfig;

                                                                                                                                                                                                                                                                                                                                  property scalars

                                                                                                                                                                                                                                                                                                                                  readonly scalars: NormalizedScalarsMap;

                                                                                                                                                                                                                                                                                                                                    method convertName

                                                                                                                                                                                                                                                                                                                                    convertName: (
                                                                                                                                                                                                                                                                                                                                    node: ASTNode | string,
                                                                                                                                                                                                                                                                                                                                    options?: BaseVisitorConvertOptions & ConvertOptions
                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                      method getFragmentName

                                                                                                                                                                                                                                                                                                                                      getFragmentName: (node: FragmentDefinitionNode | string) => string;

                                                                                                                                                                                                                                                                                                                                        method getFragmentSuffix

                                                                                                                                                                                                                                                                                                                                        getFragmentSuffix: (node: FragmentDefinitionNode | string) => string;

                                                                                                                                                                                                                                                                                                                                          method getFragmentVariableName

                                                                                                                                                                                                                                                                                                                                          getFragmentVariableName: (node: FragmentDefinitionNode | string) => string;

                                                                                                                                                                                                                                                                                                                                            method getOperationSuffix

                                                                                                                                                                                                                                                                                                                                            getOperationSuffix: (
                                                                                                                                                                                                                                                                                                                                            node: FragmentDefinitionNode | OperationDefinitionNode | string,
                                                                                                                                                                                                                                                                                                                                            operationType: string
                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                              method getPunctuation

                                                                                                                                                                                                                                                                                                                                              protected getPunctuation: (_declarationKind: DeclarationKind) => string;

                                                                                                                                                                                                                                                                                                                                                method getVisitorKindContextFromAncestors

                                                                                                                                                                                                                                                                                                                                                protected getVisitorKindContextFromAncestors: (ancestors: ASTNode[]) => string[];

                                                                                                                                                                                                                                                                                                                                                  class ClientSideBaseVisitor

                                                                                                                                                                                                                                                                                                                                                  class ClientSideBaseVisitor<
                                                                                                                                                                                                                                                                                                                                                  TRawConfig extends RawClientSideBasePluginConfig = RawClientSideBasePluginConfig,
                                                                                                                                                                                                                                                                                                                                                  TPluginConfig extends ClientSideBasePluginConfig = ClientSideBasePluginConfig
                                                                                                                                                                                                                                                                                                                                                  > extends BaseVisitor<TRawConfig, TPluginConfig> {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                    _schema: GraphQLSchema,
                                                                                                                                                                                                                                                                                                                                                    _fragments: {
                                                                                                                                                                                                                                                                                                                                                    name: string;
                                                                                                                                                                                                                                                                                                                                                    onType: string;
                                                                                                                                                                                                                                                                                                                                                    node: FragmentDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                    isExternal: boolean;
                                                                                                                                                                                                                                                                                                                                                    importFrom?: string;
                                                                                                                                                                                                                                                                                                                                                    }[],
                                                                                                                                                                                                                                                                                                                                                    rawConfig: RawClientSideBasePluginConfig,
                                                                                                                                                                                                                                                                                                                                                    additionalConfig: Partial<TPluginConfig>,
                                                                                                                                                                                                                                                                                                                                                    documents?: Types.DocumentFile[]
                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                      property fragments

                                                                                                                                                                                                                                                                                                                                                      readonly fragments: string;

                                                                                                                                                                                                                                                                                                                                                        method buildOperation

                                                                                                                                                                                                                                                                                                                                                        protected buildOperation: (
                                                                                                                                                                                                                                                                                                                                                        _node: OperationDefinitionNode,
                                                                                                                                                                                                                                                                                                                                                        _documentVariableName: string,
                                                                                                                                                                                                                                                                                                                                                        _operationType: string,
                                                                                                                                                                                                                                                                                                                                                        _operationResultType: string,
                                                                                                                                                                                                                                                                                                                                                        _operationVariablesTypes: string,
                                                                                                                                                                                                                                                                                                                                                        _hasRequiredVariables: boolean
                                                                                                                                                                                                                                                                                                                                                        ) => string;

                                                                                                                                                                                                                                                                                                                                                          method checkVariablesRequirements

                                                                                                                                                                                                                                                                                                                                                          protected checkVariablesRequirements: (node: OperationDefinitionNode) => boolean;
                                                                                                                                                                                                                                                                                                                                                          • Checks if the specific operation has variables that are non-null (required), and also doesn't have default. This is useful for deciding of variables should be optional or not.

                                                                                                                                                                                                                                                                                                                                                            Parameter node

                                                                                                                                                                                                                                                                                                                                                          method getDocumentNodeSignature

                                                                                                                                                                                                                                                                                                                                                          protected getDocumentNodeSignature: (
                                                                                                                                                                                                                                                                                                                                                          _resultType: string,
                                                                                                                                                                                                                                                                                                                                                          _variablesTypes: string,
                                                                                                                                                                                                                                                                                                                                                          _node: FragmentDefinitionNode | OperationDefinitionNode
                                                                                                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                                                                                                            method getImports

                                                                                                                                                                                                                                                                                                                                                            getImports: (options?: { excludeFragments?: boolean }) => string[];

                                                                                                                                                                                                                                                                                                                                                              method getOperationVariableName

                                                                                                                                                                                                                                                                                                                                                              getOperationVariableName: (node: OperationDefinitionNode) => string;

                                                                                                                                                                                                                                                                                                                                                                method OperationDefinition

                                                                                                                                                                                                                                                                                                                                                                OperationDefinition: (node: OperationDefinitionNode) => string;

                                                                                                                                                                                                                                                                                                                                                                  class DeclarationBlock

                                                                                                                                                                                                                                                                                                                                                                  class DeclarationBlock {}

                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                    constructor(_config: DeclarationBlockConfig);

                                                                                                                                                                                                                                                                                                                                                                      property string

                                                                                                                                                                                                                                                                                                                                                                      readonly string: string;

                                                                                                                                                                                                                                                                                                                                                                        method asKind

                                                                                                                                                                                                                                                                                                                                                                        asKind: (kind: string) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                          method export

                                                                                                                                                                                                                                                                                                                                                                          export: (exp?: boolean) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                            method withBlock

                                                                                                                                                                                                                                                                                                                                                                            withBlock: (block: string) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                              method withComment

                                                                                                                                                                                                                                                                                                                                                                              withComment: (
                                                                                                                                                                                                                                                                                                                                                                              comment: string | StringValueNode | null,
                                                                                                                                                                                                                                                                                                                                                                              disabled?: boolean
                                                                                                                                                                                                                                                                                                                                                                              ) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                                method withContent

                                                                                                                                                                                                                                                                                                                                                                                withContent: (content: string) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                                  method withDecorator

                                                                                                                                                                                                                                                                                                                                                                                  withDecorator: (decorator: string) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                                    method withMethodCall

                                                                                                                                                                                                                                                                                                                                                                                    withMethodCall: (
                                                                                                                                                                                                                                                                                                                                                                                    methodName: string,
                                                                                                                                                                                                                                                                                                                                                                                    ignoreBlockWrapper?: boolean
                                                                                                                                                                                                                                                                                                                                                                                    ) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                                      method withName

                                                                                                                                                                                                                                                                                                                                                                                      withName: (
                                                                                                                                                                                                                                                                                                                                                                                      name: string | NameNode,
                                                                                                                                                                                                                                                                                                                                                                                      generics?: string | null
                                                                                                                                                                                                                                                                                                                                                                                      ) => DeclarationBlock;

                                                                                                                                                                                                                                                                                                                                                                                        class OperationVariablesToObject

                                                                                                                                                                                                                                                                                                                                                                                        class OperationVariablesToObject {}

                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                          _scalars: NormalizedScalarsMap,
                                                                                                                                                                                                                                                                                                                                                                                          _convertName: ConvertNameFn<BaseVisitorConvertOptions>,
                                                                                                                                                                                                                                                                                                                                                                                          _namespacedImportName?: string,
                                                                                                                                                                                                                                                                                                                                                                                          _enumNames?: string[],
                                                                                                                                                                                                                                                                                                                                                                                          _enumPrefix?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                          _enumValues?: ParsedEnumValuesMap,
                                                                                                                                                                                                                                                                                                                                                                                          _applyCoercion?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                          _directiveArgumentAndInputFieldMappings?: ParsedDirectiveArgumentAndInputFieldMappings
                                                                                                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                                                                                                            method formatFieldString

                                                                                                                                                                                                                                                                                                                                                                                            protected formatFieldString: (
                                                                                                                                                                                                                                                                                                                                                                                            fieldName: string,
                                                                                                                                                                                                                                                                                                                                                                                            isNonNullType: boolean,
                                                                                                                                                                                                                                                                                                                                                                                            _hasDefaultValue: boolean
                                                                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                                                                              method formatTypeString

                                                                                                                                                                                                                                                                                                                                                                                              protected formatTypeString: (
                                                                                                                                                                                                                                                                                                                                                                                              fieldType: string,
                                                                                                                                                                                                                                                                                                                                                                                              isNonNullType: boolean,
                                                                                                                                                                                                                                                                                                                                                                                              hasDefaultValue: boolean
                                                                                                                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                method getDirectiveMapping

                                                                                                                                                                                                                                                                                                                                                                                                protected getDirectiveMapping: (name: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                  method getDirectiveOverrideType

                                                                                                                                                                                                                                                                                                                                                                                                  protected getDirectiveOverrideType: (
                                                                                                                                                                                                                                                                                                                                                                                                  directives: ReadonlyArray<DirectiveNode>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                    method getName

                                                                                                                                                                                                                                                                                                                                                                                                    getName: <TDefinitionType extends InterfaceOrVariable>(
                                                                                                                                                                                                                                                                                                                                                                                                    node: TDefinitionType
                                                                                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                      method getPunctuation

                                                                                                                                                                                                                                                                                                                                                                                                      protected getPunctuation: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                        method getScalar

                                                                                                                                                                                                                                                                                                                                                                                                        protected getScalar: (name: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                          method transform

                                                                                                                                                                                                                                                                                                                                                                                                          transform: <TDefinitionType extends InterfaceOrVariable>(
                                                                                                                                                                                                                                                                                                                                                                                                          variablesNode: ReadonlyArray<TDefinitionType>
                                                                                                                                                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                            method transformVariable

                                                                                                                                                                                                                                                                                                                                                                                                            protected transformVariable: <TDefinitionType extends InterfaceOrVariable>(
                                                                                                                                                                                                                                                                                                                                                                                                            variable: TDefinitionType
                                                                                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                              method wrapAstTypeWithModifiers

                                                                                                                                                                                                                                                                                                                                                                                                              wrapAstTypeWithModifiers: (
                                                                                                                                                                                                                                                                                                                                                                                                              _baseType: string,
                                                                                                                                                                                                                                                                                                                                                                                                              _typeNode: TypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                              _applyCoercion?: Boolean
                                                                                                                                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                class PreResolveTypesProcessor

                                                                                                                                                                                                                                                                                                                                                                                                                class PreResolveTypesProcessor extends BaseSelectionSetProcessor<SelectionSetProcessorConfig> {}

                                                                                                                                                                                                                                                                                                                                                                                                                  method transformAliasesPrimitiveFields

                                                                                                                                                                                                                                                                                                                                                                                                                  transformAliasesPrimitiveFields: (
                                                                                                                                                                                                                                                                                                                                                                                                                  schemaType: GraphQLObjectType | GraphQLInterfaceType,
                                                                                                                                                                                                                                                                                                                                                                                                                  fields: PrimitiveAliasedFields[]
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => (string | NameAndType)[];

                                                                                                                                                                                                                                                                                                                                                                                                                    method transformLinkFields

                                                                                                                                                                                                                                                                                                                                                                                                                    transformLinkFields: (fields: LinkField[]) => (string | NameAndType)[];

                                                                                                                                                                                                                                                                                                                                                                                                                      method transformPrimitiveFields

                                                                                                                                                                                                                                                                                                                                                                                                                      transformPrimitiveFields: (
                                                                                                                                                                                                                                                                                                                                                                                                                      schemaType: GraphQLObjectType | GraphQLInterfaceType,
                                                                                                                                                                                                                                                                                                                                                                                                                      fields: PrimitiveField[]
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => (string | NameAndType)[];

                                                                                                                                                                                                                                                                                                                                                                                                                        method transformTypenameField

                                                                                                                                                                                                                                                                                                                                                                                                                        transformTypenameField: (type: string, name: string) => (string | NameAndType)[];

                                                                                                                                                                                                                                                                                                                                                                                                                          class SelectionSetToObject

                                                                                                                                                                                                                                                                                                                                                                                                                          class SelectionSetToObject<
                                                                                                                                                                                                                                                                                                                                                                                                                          Config extends ParsedDocumentsConfig = ParsedDocumentsConfig
                                                                                                                                                                                                                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                            _processor: BaseSelectionSetProcessor<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                            _scalars: NormalizedScalarsMap,
                                                                                                                                                                                                                                                                                                                                                                                                                            _schema: GraphQLSchema,
                                                                                                                                                                                                                                                                                                                                                                                                                            _convertName: ConvertNameFn<BaseVisitorConvertOptions>,
                                                                                                                                                                                                                                                                                                                                                                                                                            _getFragmentSuffix: GetFragmentSuffixFn,
                                                                                                                                                                                                                                                                                                                                                                                                                            _loadedFragments: {
                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            onType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            node: FragmentDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                            isExternal: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                            importFrom?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            }[],
                                                                                                                                                                                                                                                                                                                                                                                                                            _config: ParsedDocumentsConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                            _parentSchemaType?: GraphQLNamedType,
                                                                                                                                                                                                                                                                                                                                                                                                                            _selectionSet?: SelectionSetNode
                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                              method buildFragmentSpreadsUsage

                                                                                                                                                                                                                                                                                                                                                                                                                              protected buildFragmentSpreadsUsage: (
                                                                                                                                                                                                                                                                                                                                                                                                                              spreads: FragmentSpreadNode[]
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Record<string, FragmentSpreadUsage[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                method buildFragmentTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                protected buildFragmentTypeName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                suffix: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                typeName?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method buildSelectionSet

                                                                                                                                                                                                                                                                                                                                                                                                                                  protected buildSelectionSet: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  parentSchemaType: GraphQLObjectType,
                                                                                                                                                                                                                                                                                                                                                                                                                                  selectionNodes: Array<SelectionNode | FragmentSpreadUsage | DirectiveNode>
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => { typeInfo: { name: string; type: string }; fields: string[] };

                                                                                                                                                                                                                                                                                                                                                                                                                                    method buildTypeNameField

                                                                                                                                                                                                                                                                                                                                                                                                                                    protected buildTypeNameField: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    type: GraphQLObjectType,
                                                                                                                                                                                                                                                                                                                                                                                                                                    nonOptionalTypename?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                    addTypename?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                    queriedForTypename?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                    skipTypeNameForRoot?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { name: string; type: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                      method createNext

                                                                                                                                                                                                                                                                                                                                                                                                                                      createNext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      parentSchemaType: GraphQLNamedType,
                                                                                                                                                                                                                                                                                                                                                                                                                                      selectionSet: SelectionSetNode
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => SelectionSetToObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method flattenSelectionSet

                                                                                                                                                                                                                                                                                                                                                                                                                                        protected flattenSelectionSet: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        selections: ReadonlyArray<SelectionNode>
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Map<string, Array<SelectionNode | FragmentSpreadUsage>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getEmptyObjectType

                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getEmptyObjectType: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getUnknownType

                                                                                                                                                                                                                                                                                                                                                                                                                                            protected getUnknownType: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method selectionSetStringFromFields

                                                                                                                                                                                                                                                                                                                                                                                                                                              protected selectionSetStringFromFields: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              fields: (string | NameAndType)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method transformFragmentSelectionSetToTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                transformFragmentSelectionSetToTypes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                fragmentName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                fragmentSuffix: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                declarationBlockConfig: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method transformSelectionSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                  transformSelectionSet: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AvoidOptionalsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AvoidOptionalsConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property field

                                                                                                                                                                                                                                                                                                                                                                                                                                                        field?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inputValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                          inputValue?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property object

                                                                                                                                                                                                                                                                                                                                                                                                                                                            object?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property resolvers

                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolvers?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface BaseVisitorConvertOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface BaseVisitorConvertOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property useTypesPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  useTypesPrefix?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property useTypesSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    useTypesSuffix?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ClientSideBasePluginConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ClientSideBasePluginConfig extends ParsedConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dedupeOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dedupeOperationSuffix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property documentMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          documentMode?: DocumentMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property documentNodeImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            documentNodeImport: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property documentVariablePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              documentVariablePrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property documentVariableSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                documentVariableSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property experimentalFragmentVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  experimentalFragmentVariables?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fragmentVariablePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fragmentVariablePrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fragmentVariableSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fragmentVariableSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property globalNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        globalNamespace?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gqlImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gqlImport: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property importDocumentNodeExternallyFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            importDocumentNodeExternallyFrom?: 'near-operation-file' | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property importOperationTypesFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              importOperationTypesFrom?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property noExport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noExport: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property omitOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  omitOperationSuffix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property operationResultSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operationResultSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property optimizeDocumentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      optimizeDocumentNode: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pureMagicComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pureMagicComment?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConvertOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConvertOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              suffix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transformUnderscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transformUnderscore?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeclarationBlockConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeclarationBlockConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property blockTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    blockTransformer?: (block: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property blockWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      blockWrapper?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enumNameValueSeparator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enumNameValueSeparator?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ignoreExport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ignoreExport?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeclarationKindConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeclarationKindConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property arguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arguments?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property directive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                directive?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  input?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scalar?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: DeclarationKind;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExternalParsedMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExternalParsedMapper {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            default: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property import

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              import: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isExternal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isExternal: true;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InterfaceOrVariable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InterfaceOrVariable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: ValueNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property directives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directives?: ReadonlyArray<DirectiveNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: NameNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: TypeNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property variable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable?: VariableNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InternalParsedMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InternalParsedMapper {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isExternal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isExternal: false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NamingConventionMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NamingConventionMap {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enumValues?: 'keep' | NamingConventionResolvePath | NamingConventionFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transformUnderscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          transformUnderscore?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property typeNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeNames?: 'keep' | NamingConventionResolvePath | NamingConventionFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ParsedConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ParsedConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property addTypename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addTypename: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property allowEnumStringTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allowEnumStringTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    convert: ConvertFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dedupeFragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dedupeFragments: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property emitLegacyCommonJSImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emitLegacyCommonJSImports: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property externalFragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          externalFragments: LoadedFragment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fragmentImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fragmentImports: ImportDeclaration<FragmentImport>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property immutableTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              immutableTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property inlineFragmentTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                inlineFragmentTypes: InlineFragmentTypeOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property nonOptionalTypename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nonOptionalTypename: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scalars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scalars: ParsedScalarsMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property typesPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typesPrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property typesSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typesSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property useTypeImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useTypeImports: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParsedDocumentsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParsedDocumentsConfig extends ParsedTypesConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property addTypename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addTypename: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dedupeOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dedupeOperationSuffix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property experimentalFragmentVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  experimentalFragmentVariables: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property exportFragmentSpreadSubTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    exportFragmentSpreadSubTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property globalNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      globalNamespace: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property mergeFragmentTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mergeFragmentTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property namespacedImportName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespacedImportName: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property omitOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            omitOperationSuffix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property operationResultSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operationResultSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property preResolveTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                preResolveTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property skipTypeNameForRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skipTypeNameForRoot: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ParsedImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ParsedImport {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      moduleName: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property propName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        propName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ParsedResolversConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ParsedResolversConfig extends ParsedConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property addUnderscoreToArgsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addUnderscoreToArgsType: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property allResolversTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allResolversTypeName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property avoidOptionals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                avoidOptionals: AvoidOptionalsConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contextType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contextType: ParsedMapper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultMapper: ParsedMapper | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property directiveContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      directiveContextTypes: Array<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property directiveResolverMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directiveResolverMappings: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property enumPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enumPrefix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumValues: ParsedEnumValuesMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property federation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              federation: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fieldContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fieldContextTypes: Array<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property immutableTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  immutableTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property internalResolversPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    internalResolversPrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mappers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mappers: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [typeName: string]: ParsedMapper;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property namespacedImportName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespacedImportName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onlyResolveTypeForInterfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onlyResolveTypeForInterfaces: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property optionalResolveType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optionalResolveType: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property resolverTypeSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolverTypeSuffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property resolverTypeWrapperSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolverTypeWrapperSignature: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property rootValueType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rootValueType: ParsedMapper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ParsedTypesConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ParsedTypesConfig extends ParsedConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property addUnderscoreToArgsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addUnderscoreToArgsType: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property declarationKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        declarationKind: DeclarationKindConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property directiveArgumentAndInputFieldMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directiveArgumentAndInputFieldMappings: ParsedDirectiveArgumentAndInputFieldMappings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property entireFieldWrapperValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entireFieldWrapperValue: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property enumPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumPrefix: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enumValues: ParsedEnumValuesMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fieldWrapperValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fieldWrapperValue: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ignoreEnumValuesFromSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ignoreEnumValuesFromSchema: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onlyEnums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onlyEnums: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onlyOperationTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onlyOperationTypes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property wrapEntireDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapEntireDefinitions: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property wrapFieldDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            wrapFieldDefinitions: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RawClientSideBasePluginConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RawClientSideBasePluginConfig extends RawConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dedupeOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dedupeOperationSuffix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • false Set this configuration to true if you wish to make sure to remove duplicate operation name suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property documentMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                documentMode?: DocumentMode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • graphQLTag Declares how DocumentNode are created:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - graphQLTag: graphql-tag or other modules (check gqlImport) will be used to generate document nodes. If this is used, document nodes are generated on client side i.e. the module used to generate this will be shipped to the client - documentNode: document nodes will be generated as objects when we generate the templates. - documentNodeImportFragments: Similar to documentNode except it imports external fragments instead of embedding them. - external: document nodes are imported from an external file. To be used with importDocumentNodeExternallyFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note that some plugins (like typescript-graphql-request) also supports string for this parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property documentNodeImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                documentNodeImport?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • graphql#DocumentNode Customize from which module will DocumentNode be imported from. This is useful if you want to use modules other than graphql, e.g. @graphql-typed-document-node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property documentVariablePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                documentVariablePrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • "" Changes the GraphQL operations variables prefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property documentVariableSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                documentVariableSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Document Changes the GraphQL operations variables suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property experimentalFragmentVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                experimentalFragmentVariables?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • false If set to true, it will enable support for parsing variables on fragments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fragmentVariablePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fragmentVariablePrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • "" Changes the GraphQL fragments variables prefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fragmentVariableSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fragmentVariableSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • FragmentDoc Changes the GraphQL fragments variables suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property gqlImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gqlImport?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • graphql-tag#gql Customize from which module will gql be imported from. This is useful if you want to use modules other than graphql-tag, e.g. graphql.macro.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ## graphql.macro

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  gqlImport: graphql.macro#gql

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ## Gatsby

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  gqlImport: gatsby#graphql

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property importDocumentNodeExternallyFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                importDocumentNodeExternallyFrom?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • "" This config should be used if documentMode is external. This has 2 usage:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - any string: This would be the path to import document nodes from. This can be used if we want to manually create the document nodes e.g. Use graphql-tag in a separate file and export the generated document - 'near-operation-file': This is a special mode that is intended to be used with near-operation-file preset to import document nodes from those files. If these files are .graphql files, we make use of webpack loader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  documentMode: external
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  importDocumentNodeExternallyFrom: path/to/document-node-file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  documentMode: external
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  importDocumentNodeExternallyFrom: near-operation-file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property importOperationTypesFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                importOperationTypesFrom?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • "" This config is used internally by presets, but you can use it manually to tell codegen to prefix all base types that it's using. This is useful if you wish to generate base types from typescript-operations plugin into a different file, and import it from there.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property noExport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noExport?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • false Set this configuration to true if you wish to tell codegen to generate code with no export identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property noGraphQLTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noGraphQLTag?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated. Changes the documentMode to documentNode. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property omitOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                omitOperationSuffix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • false Set this configuration to true if you wish to disable auto add suffix of operation name, like Query, Mutation, Subscription, Fragment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property operationResultSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                operationResultSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • "" Adds a suffix to generated operation result type names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property optimizeDocumentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                optimizeDocumentNode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true If you are using documentNode: documentMode | documentNodeImportFragments, you can set this to true to apply document optimizations for your GraphQL document. This will remove all "loc" and "description" fields from the compiled document, and will remove all empty arrays (such as directives, arguments and variableDefinitions).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pureMagicComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pureMagicComment?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • false This config adds PURE magic comment to the static variables to enforce treeshaking for your bundler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RawConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RawConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property allowEnumStringTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allowEnumStringTypes?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dedupeFragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dedupeFragments?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Removes fragment duplicates for reducing data transfer. It is done by removing sub-fragments imports from fragment definition Instead - all of them are imported to the Operation node. boolean false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultScalarType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultScalarType?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Allows you to override the type that unknown scalars will have. any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultScalarType: unknown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property emitLegacyCommonJSImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  emitLegacyCommonJSImports?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • true Emit legacy common js imports. Default it will be true this way it ensure that generated code works with [non-compliant bundlers](https://github.com/dotansimha/graphql-code-generator/issues/8065).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property externalFragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  externalFragments?: LoadedFragment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fragmentImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fragmentImports?: ImportDeclaration<FragmentImport>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property globalNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  globalNamespace?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property inlineFragmentTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  inlineFragmentTypes?: InlineFragmentTypeOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether fragment types should be inlined into other operations. "inline" is the default behavior and will perform deep inlining fragment types within operation type definitions. "combine" is the previous behavior that uses fragment type references without inlining the types (and might cause issues with deeply nested fragment that uses list types).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property namingConvention

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namingConvention?: NamingConvention;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • change-case-all#pascalCase Allow you to override the naming convention of the output. You can either override all namings, or specify an object with specific custom naming convention per output. The format of the converter must be a valid module#method. Allowed values for specific output are: typeNames, enumValues. You can also use "keep" to keep all GraphQL names as-is. Additionally, you can set transformUnderscore to true if you want to override the default behavior, which is to preserve underscores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available case functions in change-case-all are camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase, lowerCase, localeLowerCase, lowerCaseFirst, spongeCase, titleCase, upperCase, localeUpperCase and upperCaseFirst [See more](https://github.com/btxtiger/change-case-all)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ## Override All Names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namingConvention: change-case-all#lowerCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ## Upper-case enum values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namingConvention:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeNames: change-case-all#pascalCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumValues: change-case-all#upperCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ## Keep names as is

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namingConvention: keep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ## Remove Underscores

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namingConvention:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeNames: change-case-all#pascalCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transformUnderscore: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property nonOptionalTypename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nonOptionalTypename?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • false Automatically adds __typename field to the generated types, even when they are not specified in the selection set, and makes it non-optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nonOptionalTypename: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scalars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scalars?: ScalarsMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Extends or overrides the built-in scalars and custom GraphQL scalars to a custom type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scalars:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DateTime: Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    JSON: "{ [key: string]: any }"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property skipTypename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skipTypename?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • false Does not add __typename to the generated types, unless it was specified in the selection set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipTypename: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property strictScalars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  strictScalars?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Makes scalars strict.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If scalars are found in the schema that are not defined in scalars an error will be thrown during codegen. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    strictScalars: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typesPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typesPrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • "" Prefixes all the generated types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typesPrefix: I

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typesSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typesSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • "" Suffixes all the generated types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typesSuffix: I

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property useTypeImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  useTypeImports?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • useTypeImports boolean false Will use import type {} rather than import {} when importing only types. This gives compatibility with TypeScript's "importsNotUsedAsValues": "error" option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    useTypeImports: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RawDocumentsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RawDocumentsConfig extends RawTypesConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property dedupeOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dedupeOperationSuffix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false Set this configuration to true if you wish to make sure to remove duplicate operation name suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property experimentalFragmentVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    experimentalFragmentVariables?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false If set to true, it will enable support for parsing variables on fragments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property exportFragmentSpreadSubTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    exportFragmentSpreadSubTypes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false If set to true, it will export the sub-types created in order to make it easier to access fields declared under fragment spread.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property globalNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    globalNamespace?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false Puts all generated code under global namespace. Useful for Stencil integration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      globalNamespace: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mergeFragmentTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mergeFragmentTypes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false If set to true, merge equal fragment interfaces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property namespacedImportName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespacedImportName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property omitOperationSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    omitOperationSuffix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false Set this configuration to true if you wish to disable auto add suffix of operation name, like Query, Mutation, Subscription, Fragment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property operationResultSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operationResultSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "" Adds a suffix to generated operation result type names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preResolveTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preResolveTypes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • true Uses primitive types where possible. Set to false in order to use Pick and take use the types generated by typescript plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preResolveTypes: false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property skipTypeNameForRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipTypeNameForRoot?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false Avoid adding __typename for root types. This is ignored when a selection explicitly specifies __typename.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      skipTypeNameForRoot: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RawResolversConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RawResolversConfig extends RawConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property addUnderscoreToArgsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addUnderscoreToArgsType?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adds _ to generated Args types in order to avoid duplicate identifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addUnderscoreToArgsType: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allResolversTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allResolversTypeName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Resolvers The type name to use when exporting all resolvers signature as unified type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property avoidOptionals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      avoidOptionals?: boolean | AvoidOptionalsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • This will cause the generator to avoid using optionals (?), so all field resolvers must be implemented in order to avoid compilation errors. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Override all definition types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - typescript-resolvers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        avoidOptionals: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Override only specific definition types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        avoidOptionals:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        field: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inputValue: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        object: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property contextType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contextType?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use this configuration to set a custom type for your context, and it will affect all the resolvers, without the need to override it using generics each time. If you wish to use an external type and import it from another file, you can use add plugin and add the required import statement, or you can use a module#type syntax.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom Context Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contextType: MyContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom Context Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contextType: ./my-types#MyContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultMapper?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Allow you to set the default mapper when it's not being override by mappers or generics. You can specify a type name, or specify a string in module#type or module#namespace#type format. The default value of mappers is the TypeScript type generated by typescript package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Replace with any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultMapper: any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom Base Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultMapper: ./my-file#BaseObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Wrap default types with Partial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can also specify a custom wrapper for the original type, without overriding the original generated types, use {T} to specify the identifier. (for flow, use $Shape<{T}>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultMapper: Partial<{T}>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Allow deep partial with utility-types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - 'typescript'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - 'typescript-resolvers'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - add:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        content: "import { DeepPartial } from 'utility-types';"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultMapper: DeepPartial<{T}>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property directiveContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      directiveContextTypes?: Array<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use this to set a custom type for a specific field context decorated by a directive. It will only affect the targeted resolvers. You can either use Field.Path#ContextTypeName or Field.Path#ExternalFileName#ContextTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ContextTypeName should by a generic Type that take the context or field context type as only type parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Directive Context Extender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directiveContextTypes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - myCustomDirectiveName#./my-file#CustomContextExtender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property directiveResolverMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      directiveResolverMappings?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enumPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enumPrefix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • true Allow you to disable prefixing for generated enums, works in combination with typesPrefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Disable enum prefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typesPrefix: I
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enumPrefix: false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enumValues?: EnumValuesMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Overrides the default value of enum values declared in your GraphQL schema, supported in this plugin because of the need for integration with typescript package. See documentation under typescript plugin for more information and examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property federation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      federation?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • false Supports Apollo Federation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fieldContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldContextTypes?: Array<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use this to set a custom type for a specific field context. It will only affect the targeted resolvers. You can either use Field.Path#ContextTypeName or Field.Path#ExternalFileName#ContextTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom Field Context Types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fieldContextTypes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - MyType.foo#CustomContextType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - MyType.bar#./my-file#ContextTypeOne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property immutableTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      immutableTypes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • false Generates immutable types by adding readonly to properties and uses ReadonlyArray.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property internalResolversPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      internalResolversPrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • string '__' Defines the prefix value used for __resolveType and __isTypeOf resolvers. If you are using mercurius-js, please set this field to empty string for better compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mappers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mappers?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [typeName: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Replaces a GraphQL type usage with a custom type, allowing you to return custom object from your resolvers. You can use both module#type and module#namespace#type syntax.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom Context Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mappers:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        User: ./my-models#UserDbObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Book: ./my-models#Collections#Book

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mapperTypeSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mapperTypeSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adds a suffix to the imported names to prevent name clashes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mapperTypeSuffix: Model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property namespacedImportName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespacedImportName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • '' Prefixes all GraphQL related generated types with that value, as namespaces import. You can use this feature to allow separation of plugins to different files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onlyResolveTypeForInterfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onlyResolveTypeForInterfaces?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • boolean false Turning this flag to true will generate resolver signature that has only resolveType for interfaces, forcing developers to write inherited type resolvers in the type itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property optionalResolveType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      optionalResolveType?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • false Sets the __resolveType field as optional field.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property resolverTypeSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolverTypeSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Resolvers Suffix we add to each generated type resolver.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property resolverTypeWrapperSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolverTypeWrapperSignature?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Promise | T Allow you to override resolverTypeWrapper definition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property rootValueType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rootValueType?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use this configuration to set a custom type for the rootValue, and it will affect resolvers of all root types (Query, Mutation and Subscription), without the need to override it using generics each time. If you wish to use an external type and import it from another file, you can use add plugin and add the required import statement, or you can use both module#type or module#namespace#type syntax.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom RootValue Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rootValueType: MyRootValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## Custom RootValue Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rootValueType: ./my-types#MyRootValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property showUnusedMappers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showUnusedMappers?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Warns about unused mappers. true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - typescript-resolvers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showUnusedMappers: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RawTypesConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RawTypesConfig extends RawConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property addUnderscoreToArgsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addUnderscoreToArgsType?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adds _ to generated Args types in order to avoid duplicate identifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## With Custom Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addUnderscoreToArgsType: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property declarationKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        declarationKind?: DeclarationKind | DeclarationKindConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default output for various GraphQL elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Override all declarations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          declarationKind: 'interface'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Override only specific declarations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          declarationKind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'interface'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          input: 'interface'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property directiveArgumentAndInputFieldMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directiveArgumentAndInputFieldMappings?: DirectiveArgumentAndInputFieldMappings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Replaces a GraphQL scalar with a custom type based on the applied directive on an argument or input field.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can use both module#type and module#namespace#type syntax. Will NOT work with introspected schemas since directives are not exported. Only works with directives on ARGUMENT_DEFINITION or INPUT_FIELD_DEFINITION.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          **WARNING:** Using this option does only change the type definitions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For actually ensuring that a type is correct at runtime you will have to use schema transforms (e.g. with [@graphql-tools/utils mapSchema](https://graphql-tools.com/docs/schema-directives)) that apply those rules! Otherwise, you might end up with a runtime type mismatch which could cause unnoticed bugs or runtime errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Please use this configuration option with care!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Custom Context Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directiveArgumentAndInputFieldMappings:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AsNumber: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AsComplex: ./my-models#Complex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property directiveArgumentAndInputFieldMappingTypeSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directiveArgumentAndInputFieldMappingTypeSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adds a suffix to the imported names to prevent name clashes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directiveArgumentAndInputFieldMappingTypeSuffix: Model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property entireFieldWrapperValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        entireFieldWrapperValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • entireFieldWrapperValue string Allow to override the type value of EntireFieldWrapper. This wrapper applies outside of Array and Maybe unlike fieldWrapperValue, that will wrap the inner type. T | Promise | (() => T | Promise)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only allow values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entireFieldWrapperValue: T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enumPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enumPrefix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • true Allow you to disable prefixing for generated enums, works in combination with typesPrefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Disable enum prefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typesPrefix: I
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enumPrefix: false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enumValues?: EnumValuesMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default value of enum values declared in your GraphQL schema. You can also map the entire enum to an external type by providing a string that of module#type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## With Custom Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enumValues:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MyEnum:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A: 'foo'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## With External Enum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enumValues:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MyEnum: ./my-file#MyCustomEnum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Import All Enums from a file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enumValues: ./my-file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fieldWrapperValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fieldWrapperValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Allow you to add wrapper for field type, use T as the generic value. Make sure to set wrapFieldDefinitions to true in order to make this flag work. T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Allow Promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapFieldDefinitions: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fieldWrapperValue: T | Promise<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ignoreEnumValuesFromSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ignoreEnumValuesFromSchema?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • This will cause the generator to ignore enum values defined in GraphQLSchema false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Ignore enum values from schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ignoreEnumValuesFromSchema: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onlyEnums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onlyEnums?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • This will cause the generator to emit types for enums only false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Override all definition types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onlyEnums: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onlyOperationTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onlyOperationTypes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • This will cause the generator to emit types for operations only (basically only enums and scalars) false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Override all definition types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onlyOperationTypes: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property wrapEntireFieldDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrapEntireFieldDefinitions?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • wrapEntireFieldDefinitions boolean Set to true in order to wrap field definitions with EntireFieldWrapper. This is useful to allow return types such as Promises and functions for fields. Differs from wrapFieldDefinitions in that this wraps the entire field definition if i.e. the field is an Array, while wrapFieldDefinitions will wrap every single value inside the array. true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable wrapping entire fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapEntireFieldDefinitions: false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property wrapFieldDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrapFieldDefinitions?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Set to true in order to wrap field definitions with FieldWrapper. This is useful to allow return types such as Promises and functions. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ## Enable wrapping fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path/to/file.ts:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plugins:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapFieldDefinitions: true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DocumentMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DocumentMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        graphQLTag = 'graphQLTag',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        documentNode = 'documentNode',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        documentNodeImportFragments = 'documentNodeImportFragments',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        external = 'external',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        string = 'string',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member documentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          documentNode = 'documentNode'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member documentNodeImportFragments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            documentNodeImportFragments = 'documentNodeImportFragments'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member external

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              external = 'external'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member graphQLTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                graphQLTag = 'graphQLTag'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  string = 'string'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ConvertFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ConvertFn<T = {}> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ASTNode | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: ConvertOptions & T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ConvertNameFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ConvertNameFn<T = {}> = ConvertFn<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeclarationKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeclarationKind = 'type' | 'interface' | 'class' | 'abstract class';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DirectiveArgumentAndInputFieldMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DirectiveArgumentAndInputFieldMappings = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A map between the GraphQL directive name and the identifier that should be used

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnumValuesMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnumValuesMap<AdditionalProps = {}> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [enumName: string]:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & AdditionalProps);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A raw configuration for enumValues map - can be represented with a single string value for a file path, a map between enum name and a file path, or a map between enum name and an object with explicit enum values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FragmentImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FragmentImport = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: 'type' | 'document';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetFragmentSuffixFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetFragmentSuffixFn = (node: FragmentDefinitionNode | string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GroupedMappers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GroupedMappers = Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              identifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asDefault?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ImportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ImportDeclaration<T = string> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outputPath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                importSource: ImportSource<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                baseOutputDir: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                baseDir: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typesImport: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                emitLegacyCommonJSImports: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ImportSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ImportSource<T = string> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Source path, relative to the `baseOutputDir`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Namespace to import source as
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Entity names to import
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  identifiers?: T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InlineFragmentTypeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InlineFragmentTypeOptions = 'inline' | 'combine' | 'mask';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LinkField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LinkField = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alias: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selectionSet: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LoadedFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LoadedFragment<AdditionalFields = {}> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: FragmentDefinitionNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isExternal: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        importFrom?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & AdditionalFields;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NameAndType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NameAndType = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NamingConvention

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NamingConvention = string | NamingConventionFn | NamingConventionMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NamingConventionFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NamingConventionFn = (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NamingConventionResolvePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NamingConventionResolvePath = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NormalizedScalarsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NormalizedScalarsMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A normalized map between GraphQL scalar name and the identifier name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ParsedDirectiveArgumentAndInputFieldMappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ParsedDirectiveArgumentAndInputFieldMappings = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [name: string]: ParsedMapper;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Parsed directives map - a mapping between GraphQL directive name and the parsed mapper object, including all required information for generating code for that mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ParsedEnumValuesMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ParsedEnumValuesMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [enumName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mappedValues?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [valueName: string]: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceIdentifier?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceFile?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  importIdentifier?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDefault?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParsedMapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParsedMapper = InternalParsedMapper | ExternalParsedMapper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ParsedScalarsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ParsedScalarsMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: ParsedMapper;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Parsed scalars map - a mapping between GraphQL scalar name and the parsed mapper object, including all required information for generting code for that mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PrimitiveAliasedFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PrimitiveAliasedFields = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alias: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fieldName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PrimitiveField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PrimitiveField = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isConditional: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fieldName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProcessResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProcessResult = null | Array<NameAndType | string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ResolverParentTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ResolverParentTypes = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [gqlType: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ResolverTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ResolverTypes = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [gqlType: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ScalarsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ScalarsMap =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Scalars map or a string, a map between the GraphQL scalar name and the identifier that should be used

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectionSetProcessorConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectionSetProcessorConfig = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespacedImportName: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                convertName: ConvertNameFn<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enumPrefix: boolean | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scalars: ScalarsMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                formatNamedField(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type?: GraphQLOutputType | GraphQLNamedType | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isConditional?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wrapTypeWithModifiers(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                baseType: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: GraphQLOutputType | GraphQLNamedType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                avoidOptionals?: AvoidOptionalsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (20)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (10)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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-codegen/visitor-plugin-common.

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