@graphql-tools/wrap 8.3.4-alpha-9e783a2c.0 → 8.4.0

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@graphql-tools/wrap",
-  "version": "8.3.4-alpha-9e783a2c.0",
+  "version": "8.4.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "8.4.4-alpha-9e783a2c.0",
-    "@graphql-tools/schema": "8.3.2-alpha-9e783a2c.0",
-    "@graphql-tools/utils": "8.6.2-alpha-9e783a2c.0",
+    "@graphql-tools/delegate": "^8.5.0",
+    "@graphql-tools/schema": "^8.3.1",
+    "@graphql-tools/utils": "^8.5.3",
     "tslib": "~2.3.0",
     "value-or-promise": "1.0.11"
   },

package/transforms/ExtractField.d.ts

@@ -1,11 +1,14 @@
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
-export default class ExtractField implements Transform {
+interface ExtractFieldTransformationContext extends Record<string, any> {
+}
+export default class ExtractField<TContext = Record<string, any>> implements Transform<ExtractFieldTransformationContext, TContext> {
     private readonly from;
     private readonly to;
     constructor({ from, to }: {
         from: Array<string>;
         to: Array<string>;
     });
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: ExtractFieldTransformationContext): ExecutionRequest;
 }
+export {};

package/transforms/FilterInputObjectFields.d.ts

@@ -2,9 +2,12 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, InputFieldFilter } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { InputObjectNodeTransformer } from '../types';
-export default class FilterInputObjectFields implements Transform {
+interface FilterInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterInputObjectFields<TContext = Record<string, any>> implements Transform<FilterInputObjectFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: InputFieldFilter, inputObjectNodeTransformer?: InputObjectNodeTransformer);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: FilterInputObjectFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/transforms/FilterInterfaceFields.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { FieldFilter } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterInterfaceFields implements Transform {
+interface FilterInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterInterfaceFields<TContext = Record<string, any>> implements Transform<FilterInterfaceFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: FieldFilter);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/FilterObjectFieldDirectives.d.ts

@@ -1,7 +1,10 @@
 import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterObjectFieldDirectives implements Transform {
+interface FilterObjectFieldDirectivesTransformationContext extends Record<string, any> {
+}
+export default class FilterObjectFieldDirectives<TContext = Record<string, any>> implements Transform<FilterObjectFieldDirectivesTransformationContext, TContext> {
     private readonly filter;
     constructor(filter: (dirName: string, dirValue: any) => boolean);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/FilterObjectFields.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { ObjectFieldFilter } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterObjectFields implements Transform {
+interface FilterObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterObjectFields<TContext = Record<string, any>> implements Transform<FilterObjectFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: ObjectFieldFilter);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/FilterRootFields.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { RootFieldFilter } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterRootFields implements Transform {
+interface FilterRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterRootFields<TContext = Record<string, any>> implements Transform<FilterRootFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: RootFieldFilter);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/FilterTypes.d.ts

@@ -1,7 +1,10 @@
 import { GraphQLSchema, GraphQLNamedType } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterTypes implements Transform {
+interface FilterTypesTransformationContext extends Record<string, any> {
+}
+export default class FilterTypes<TContext = Record<string, any>> implements Transform<FilterTypesTransformationContext, TContext> {
     private readonly filter;
     constructor(filter: (type: GraphQLNamedType) => boolean);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/HoistField.d.ts

@@ -1,7 +1,9 @@
 import { GraphQLSchema, FieldNode, GraphQLArgument } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class HoistField implements Transform {
+interface HoistFieldTransformationContext extends Record<string, any> {
+}
+export default class HoistField<TContext = Record<string, any>> implements Transform<HoistFieldTransformationContext, TContext> {
     private readonly typeName;
     private readonly newFieldName;
     private readonly pathToField;
@@ -13,10 +15,11 @@ export default class HoistField implements Transform {
         fieldName: string;
         argFilter?: (arg: GraphQLArgument) => boolean;
     }>, newFieldName: string, alias?: string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: HoistFieldTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: HoistFieldTransformationContext): ExecutionResult;
 }
 export declare function wrapFieldNode(fieldNode: FieldNode, path: Array<string>, alias: string, argLevels: Record<string, number>): FieldNode;
 export declare function renameFieldNode(fieldNode: FieldNode, name: string): FieldNode;
 export declare function unwrapValue(originalValue: any, alias: string): any;
+export {};

package/transforms/MapFields.d.ts

@@ -2,7 +2,9 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, FieldNodeMappers, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { ObjectValueTransformerMap, ErrorsTransformer } from '../types';
-export default class MapFields<TContext> implements Transform<any, TContext> {
+interface MapFieldsTransformationContext extends Record<string, any> {
+}
+export default class MapFields<TContext> implements Transform<MapFieldsTransformationContext, TContext> {
     private fieldNodeTransformerMap;
     private objectValueTransformerMap?;
     private errorsTransformer?;
@@ -10,6 +12,7 @@ export default class MapFields<TContext> implements Transform<any, TContext> {
     constructor(fieldNodeTransformerMap: FieldNodeMappers, objectValueTransformerMap?: ObjectValueTransformerMap, errorsTransformer?: ErrorsTransformer);
     private _getTransformer;
     transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: MapFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: MapFieldsTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/MapLeafValues.d.ts

@@ -5,7 +5,7 @@ import { LeafValueTransformer } from '../types';
 export interface MapLeafValuesTransformationContext {
     transformedRequest: ExecutionRequest;
 }
-export default class MapLeafValues implements Transform<MapLeafValuesTransformationContext> {
+export default class MapLeafValues<TContext = Record<string, any>> implements Transform<MapLeafValuesTransformationContext, TContext> {
     private readonly inputValueTransformer;
     private readonly outputValueTransformer;
     private readonly resultVisitorMap;
@@ -14,9 +14,9 @@ export default class MapLeafValues implements Transform<MapLeafValuesTransformat
     constructor(inputValueTransformer: LeafValueTransformer, outputValueTransformer: LeafValueTransformer);
     private _getTypeInfo;
     private _getOriginalWrappingSchema;
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, transformationContext: MapLeafValuesTransformationContext): ExecutionResult;
     private transformOperations;
     private transformFieldNode;
 }

package/transforms/PruneSchema.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { PruneSchemaOptions } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class PruneTypes implements Transform {
+interface PruneTypesTransformationContext extends Record<string, any> {
+}
+export default class PruneTypes<TContext = Record<string, any>> implements Transform<PruneTypesTransformationContext, TContext> {
     private readonly options;
     constructor(options?: PruneSchemaOptions);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/RemoveObjectFieldDeprecations.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class RemoveObjectFieldDeprecations implements Transform {
+interface RemoveObjectFieldDeprecationsTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldDeprecations<TContext = Record<string, any>> implements Transform<RemoveObjectFieldDeprecationsTransformationContext, TContext> {
     private readonly removeDirectives;
     private readonly removeDeprecations;
     constructor(reason: string | RegExp);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/RemoveObjectFieldDirectives.d.ts

@@ -1,7 +1,10 @@
 import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class RemoveObjectFieldDirectives implements Transform {
+interface RemoveObjectFieldDirectivesTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldDirectives<TContext = Record<string, any>> implements Transform<RemoveObjectFieldDirectivesTransformationContext, TContext> {
     private readonly transformer;
     constructor(directiveName: string | RegExp, args?: Record<string, any>);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/RemoveObjectFieldsWithDeprecation.d.ts

@@ -1,7 +1,10 @@
 import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class RemoveObjectFieldsWithDeprecation implements Transform {
+interface RemoveObjectFieldsWithDeprecationTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldsWithDeprecation<TContext = Record<string, any>> implements Transform<RemoveObjectFieldsWithDeprecationTransformationContext, TContext> {
     private readonly transformer;
     constructor(reason: string | RegExp);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/RemoveObjectFieldsWithDirective.d.ts

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class RemoveObjectFieldsWithDirective implements Transform {
+interface RemoveObjectFieldsWithDirectiveTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldsWithDirective<TContext = Record<string, any>> implements Transform<RemoveObjectFieldsWithDirectiveTransformationContext, TContext> {
     private readonly directiveName;
     private readonly args;
     constructor(directiveName: string | RegExp, args?: Record<string, any>);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
 }
+export {};

package/transforms/RenameInputObjectFields.d.ts

@@ -2,12 +2,14 @@ import { GraphQLSchema, GraphQLInputFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 declare type RenamerFunction = (typeName: string, fieldName: string, inputFieldConfig: GraphQLInputFieldConfig) => string | undefined;
-export default class RenameInputObjectFields implements Transform {
+interface RenameInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameInputObjectFields<TContext = Record<string, any>> implements Transform<RenameInputObjectFieldsTransformationContext, TContext> {
     private readonly renamer;
     private readonly transformer;
     private reverseMap;
     constructor(renamer: RenamerFunction);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInputObjectFieldsTransformationContext): ExecutionRequest;
 }
 export {};

package/transforms/RenameInterfaceFields.d.ts

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameInterfaceFields implements Transform {
+interface RenameInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameInterfaceFields<TContext = Record<string, any>> implements Transform<RenameInterfaceFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInterfaceFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/transforms/RenameObjectFields.d.ts

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameObjectFields implements Transform {
+interface RenameObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameObjectFields<TContext = Record<string, any>> implements Transform<RenameObjectFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameObjectFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/transforms/RenameRootFields.d.ts

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameRootFields implements Transform {
+interface RenameRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameRootFields<TContext = Record<string, any>> implements Transform<RenameRootFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (operation: 'Query' | 'Mutation' | 'Subscription', name: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameRootFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/transforms/RenameRootTypes.d.ts

@@ -1,12 +1,15 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameRootTypes implements Transform {
+interface RenameRootTypesTransformationContext extends Record<string, any> {
+}
+export default class RenameRootTypes<TContext = Record<string, any>> implements Transform<RenameRootTypesTransformationContext, TContext> {
     private readonly renamer;
     private map;
     private reverseMap;
     constructor(renamer: (name: string) => string | undefined);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, _transformationContext?: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: RenameRootTypesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext?: RenameRootTypesTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/RenameTypes.d.ts

@@ -1,14 +1,17 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult, RenameTypesOptions } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameTypes implements Transform {
+interface RenameTypesTransformationContext extends Record<string, any> {
+}
+export default class RenameTypes<TContext = Record<string, any>> implements Transform<RenameTypesTransformationContext, TContext> {
     private readonly renamer;
     private map;
     private reverseMap;
     private readonly renameBuiltins;
     private readonly renameScalars;
     constructor(renamer: (name: string) => string | undefined, options?: RenameTypesOptions);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, _transformationContext?: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: RenameTypesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext?: RenameTypesTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/TransformCompositeFields.d.ts

@@ -2,7 +2,9 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { FieldTransformer, FieldNodeTransformer, DataTransformer, ErrorsTransformer } from '../types';
-export default class TransformCompositeFields<TContext = Record<string, any>> implements Transform<any, TContext> {
+interface TransformCompositeFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformCompositeFields<TContext = Record<string, any>> implements Transform<TransformCompositeFieldsTransformationContext, TContext> {
     private readonly fieldTransformer;
     private readonly fieldNodeTransformer;
     private readonly dataTransformer;
@@ -11,11 +13,12 @@ export default class TransformCompositeFields<TContext = Record<string, any>> im
     private typeInfo;
     private mapping;
     private subscriptionTypeName;
-    constructor(fieldTransformer: FieldTransformer, fieldNodeTransformer?: FieldNodeTransformer, dataTransformer?: DataTransformer, errorsTransformer?: ErrorsTransformer);
+    constructor(fieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer, dataTransformer?: DataTransformer, errorsTransformer?: ErrorsTransformer);
     private _getTypeInfo;
     transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(result: ExecutionResult, _delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionRequest;
+    transformResult(result: ExecutionResult, _delegationContext: DelegationContext<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionResult;
     private transformDocument;
     private transformSelectionSet;
 }
+export {};

package/transforms/TransformEnumValues.d.ts

@@ -3,15 +3,18 @@ import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { EnumValueTransformer, LeafValueTransformer } from '../types';
 import { MapLeafValuesTransformationContext } from './MapLeafValues';
-export default class TransformEnumValues implements Transform<MapLeafValuesTransformationContext> {
+interface TransformEnumValuesTransformationContext extends MapLeafValuesTransformationContext {
+}
+export default class TransformEnumValues<TContext = Record<string, any>> implements Transform<TransformEnumValuesTransformationContext, TContext> {
     private readonly enumValueTransformer;
     private readonly transformer;
     private transformedSchema;
     private mapping;
     private reverseMapping;
     constructor(enumValueTransformer: EnumValueTransformer, inputValueTransformer?: LeafValueTransformer, outputValueTransformer?: LeafValueTransformer);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): import("@graphql-tools/utils").ExecutionResult<Record<string, any>>;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformEnumValuesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformEnumValuesTransformationContext): import("@graphql-tools/utils").ExecutionResult<Record<string, any>>;
     private transformEnumValue;
 }
+export {};

package/transforms/TransformInputObjectFields.d.ts

@@ -2,7 +2,9 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { InputFieldTransformer, InputFieldNodeTransformer, InputObjectNodeTransformer } from '../types';
-export default class TransformInputObjectFields implements Transform {
+interface TransformInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformInputObjectFields<TContext = Record<string, any>> implements Transform<TransformInputObjectFieldsTransformationContext, TContext> {
     private readonly inputFieldTransformer;
     private readonly inputFieldNodeTransformer;
     private readonly inputObjectNodeTransformer;
@@ -10,7 +12,8 @@ export default class TransformInputObjectFields implements Transform {
     private mapping;
     constructor(inputFieldTransformer: InputFieldTransformer, inputFieldNodeTransformer?: InputFieldNodeTransformer, inputObjectNodeTransformer?: InputObjectNodeTransformer);
     private _getTransformedSchema;
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, _transformationContext: TransformInputObjectFieldsTransformationContext): ExecutionRequest;
     private transformDocument;
 }
+export {};

package/transforms/TransformInterfaceFields.d.ts

@@ -2,13 +2,16 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { FieldTransformer, FieldNodeTransformer } from '../types';
-export default class TransformInterfaceFields implements Transform {
+interface TransformInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformInterfaceFields<TContext = Record<string, any>> implements Transform<TransformInterfaceFieldsTransformationContext, TContext> {
     private readonly interfaceFieldTransformer;
     private readonly fieldNodeTransformer;
     private transformer;
-    constructor(interfaceFieldTransformer: FieldTransformer, fieldNodeTransformer?: FieldNodeTransformer);
+    constructor(interfaceFieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
     private _getTransformer;
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformInterfaceFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformInterfaceFieldsTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/TransformObjectFields.d.ts

@@ -2,13 +2,16 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { FieldTransformer, FieldNodeTransformer } from '../types';
-export default class TransformObjectFields implements Transform {
+interface TransformObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformObjectFields<TContext = Record<string, any>> implements Transform<TransformObjectFieldsTransformationContext, TContext> {
     private readonly objectFieldTransformer;
     private readonly fieldNodeTransformer;
     private transformer;
-    constructor(objectFieldTransformer: FieldTransformer, fieldNodeTransformer?: FieldNodeTransformer);
+    constructor(objectFieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
     private _getTransformer;
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformObjectFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformObjectFieldsTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/TransformQuery.d.ts

@@ -1,10 +1,12 @@
 import { SelectionSetNode, FragmentDefinitionNode } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
-export declare type QueryTransformer = (selectionSet: SelectionSetNode, fragments: Record<string, FragmentDefinitionNode>, delegationContext: DelegationContext, transformationContext: Record<string, any>) => SelectionSetNode;
-export declare type ResultTransformer = (result: any, delegationContext: DelegationContext, transformationContext: Record<string, any>) => any;
+export declare type QueryTransformer = <TContext>(selectionSet: SelectionSetNode, fragments: Record<string, FragmentDefinitionNode>, delegationContext: DelegationContext<TContext>, transformationContext: Record<string, any>) => SelectionSetNode;
+export declare type ResultTransformer = <TContext>(result: any, delegationContext: DelegationContext<TContext>, transformationContext: Record<string, any>) => any;
 export declare type ErrorPathTransformer = (path: ReadonlyArray<string | number>) => Array<string | number>;
-export default class TransformQuery implements Transform {
+interface TransformQueryTransformationContext extends Record<string, any> {
+}
+export default class TransformQuery<TContext = Record<string, any>> implements Transform<TransformQueryTransformationContext, TContext> {
     private readonly path;
     private readonly queryTransformer;
     private readonly resultTransformer;
@@ -17,8 +19,9 @@ export default class TransformQuery implements Transform {
         errorPathTransformer?: ErrorPathTransformer;
         fragments?: Record<string, FragmentDefinitionNode>;
     });
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionResult;
     private transformData;
     private transformErrors;
 }
+export {};

package/transforms/TransformRootFields.d.ts

@@ -2,13 +2,16 @@ import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { RootFieldTransformer, FieldNodeTransformer } from '../types';
-export default class TransformRootFields implements Transform {
+interface TransformRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformRootFields<TContext = Record<string, any>> implements Transform<TransformRootFieldsTransformationContext, TContext> {
     private readonly rootFieldTransformer;
     private readonly fieldNodeTransformer;
     private transformer;
-    constructor(rootFieldTransformer: RootFieldTransformer, fieldNodeTransformer?: FieldNodeTransformer);
+    constructor(rootFieldTransformer: RootFieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
     private _getTransformer;
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformRootFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformRootFieldsTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/WrapFields.d.ts

@@ -17,8 +17,8 @@ export default class WrapFields<TContext> implements Transform<WrapFieldsTransfo
     private readonly transformer;
     constructor(outerTypeName: string, wrappingFieldNames: Array<string>, wrappingTypeNames: Array<string>, fieldNames?: Array<string>, prefix?: string);
     transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: WrapFieldsTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: WrapFieldsTransformationContext): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionResult;
 }
 export declare function dehoistValue(originalValue: any, context: WrapFieldsTransformationContext): any;
 export {};

package/transforms/WrapQuery.d.ts

@@ -2,11 +2,14 @@ import { SelectionNode, SelectionSetNode } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
 export declare type QueryWrapper = (subtree: SelectionSetNode) => SelectionNode | SelectionSetNode;
-export default class WrapQuery implements Transform {
+interface WrapQueryTransformationContext extends Record<string, any> {
+}
+export default class WrapQuery<TContext = Record<string, any>> implements Transform<WrapQueryTransformationContext, TContext> {
     private readonly wrapper;
     private readonly extractor;
     private readonly path;
     constructor(path: Array<string>, wrapper: QueryWrapper, extractor: (result: any) => any);
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionResult;
 }
+export {};

package/transforms/WrapType.d.ts

@@ -1,10 +1,13 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class WrapType implements Transform {
+interface WrapTypeTransformationContext extends Record<string, any> {
+}
+export default class WrapType<TContext = Record<string, any>> implements Transform<WrapTypeTransformationContext, TContext> {
     private readonly transformer;
     constructor(outerTypeName: string, innerTypeName: string, fieldName: string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: WrapTypeTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: WrapTypeTransformationContext): ExecutionResult;
 }
+export {};

package/types.d.ts

@@ -2,8 +2,8 @@ import { GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinit
 import { DelegationContext } from '@graphql-tools/delegate';
 import { ExecutionRequest, Maybe } from '@graphql-tools/utils';
 export declare type InputFieldTransformer = (typeName: string, fieldName: string, inputFieldConfig: GraphQLInputFieldConfig) => GraphQLInputFieldConfig | [string, GraphQLInputFieldConfig] | null | undefined;
-export declare type InputFieldNodeTransformer = (typeName: string, fieldName: string, inputFieldNode: ObjectFieldNode, request: ExecutionRequest, delegationContext?: DelegationContext) => ObjectFieldNode | Array<ObjectFieldNode>;
-export declare type InputObjectNodeTransformer = (typeName: string, inputObjectNode: ObjectValueNode, request: ExecutionRequest, delegationContext?: DelegationContext) => ObjectValueNode | undefined;
+export declare type InputFieldNodeTransformer = <TContext>(typeName: string, fieldName: string, inputFieldNode: ObjectFieldNode, request: ExecutionRequest, delegationContext?: DelegationContext<TContext>) => ObjectFieldNode | Array<ObjectFieldNode>;
+export declare type InputObjectNodeTransformer = <TContext>(typeName: string, inputObjectNode: ObjectValueNode, request: ExecutionRequest, delegationContext?: DelegationContext<TContext>) => ObjectValueNode | undefined;
 export declare type FieldTransformer<TContext = Record<string, any>> = (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, TContext>) => Maybe<GraphQLFieldConfig<any, TContext> | [string, GraphQLFieldConfig<any, TContext>]>;
 export declare type RootFieldTransformer<TContext = Record<string, any>> = (operation: 'Query' | 'Mutation' | 'Subscription', fieldName: string, fieldConfig: GraphQLFieldConfig<any, TContext>) => Maybe<GraphQLFieldConfig<any, TContext> | [string, GraphQLFieldConfig<any, TContext>]>;
 export declare type EnumValueTransformer = (typeName: string, externalValue: string, enumValueConfig: GraphQLEnumValueConfig) => Maybe<GraphQLEnumValueConfig | [string, GraphQLEnumValueConfig]>;