@graphql-tools/wrap 8.5.2-alpha-e7752ba5.0 → 8.5.2-alpha-b9e4a92b.0

package/typings/transforms/RemoveObjectFieldsWithDeprecation.d.cts

@@ -0,0 +1,10 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+}
+export {};

package/typings/transforms/RemoveObjectFieldsWithDeprecation.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
 interface RemoveObjectFieldsWithDeprecationTransformationContext extends Record<string, any> {
 }

package/typings/transforms/RemoveObjectFieldsWithDirective.d.cts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+}
+export {};

package/typings/transforms/RemoveObjectFieldsWithDirective.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
 interface RemoveObjectFieldsWithDirectiveTransformationContext extends Record<string, any> {
 }

package/typings/transforms/RenameInputObjectFields.d.cts

@@ -0,0 +1,15 @@
+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;
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInputObjectFieldsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/RenameInputObjectFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLInputFieldConfig } from '@graphql-tools/graphql';
+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;

package/typings/transforms/RenameInterfaceFields.d.cts

@@ -0,0 +1,12 @@
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInterfaceFieldsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/RenameInterfaceFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLFieldConfig } from '@graphql-tools/graphql';
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface RenameInterfaceFieldsTransformationContext extends Record<string, any> {

package/typings/transforms/RenameObjectFieldArguments.d.cts

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+declare type RenamerFunction = (typeName: string, fieldName: string, argName: string) => string;
+interface RenameObjectFieldArgumentsTransformationContext extends Record<string, any> {
+}
+export default class RenameObjectFieldArguments<TContext = Record<string, any>> implements Transform<RenameObjectFieldArgumentsTransformationContext, TContext> {
+    private readonly renamer;
+    private readonly transformer;
+    private reverseMap;
+    constructor(renamer: RenamerFunction);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameObjectFieldArgumentsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/RenameObjectFieldArguments.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 declare type RenamerFunction = (typeName: string, fieldName: string, argName: string) => string;

package/typings/transforms/RenameObjectFields.d.cts

@@ -0,0 +1,12 @@
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameObjectFieldsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/RenameObjectFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLFieldConfig } from '@graphql-tools/graphql';
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface RenameObjectFieldsTransformationContext extends Record<string, any> {

package/typings/transforms/RenameRootFields.d.cts

@@ -0,0 +1,12 @@
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+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<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameRootFieldsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/RenameRootFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLFieldConfig } from '@graphql-tools/graphql';
+import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface RenameRootFieldsTransformationContext extends Record<string, any> {

package/typings/transforms/RenameRootTypes.d.cts

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+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<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/typings/transforms/RenameRootTypes.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface RenameRootTypesTransformationContext extends Record<string, any> {

package/typings/transforms/RenameTypes.d.cts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult, RenameTypesOptions } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+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<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/typings/transforms/RenameTypes.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult, RenameTypesOptions } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface RenameTypesTransformationContext extends Record<string, any> {

package/typings/transforms/TransformCompositeFields.d.cts

@@ -0,0 +1,24 @@
+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.cjs';
+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;
+    private readonly errorsTransformer;
+    private transformedSchema;
+    private typeInfo;
+    private mapping;
+    private subscriptionTypeName;
+    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<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionRequest;
+    transformResult(result: ExecutionResult, _delegationContext: DelegationContext<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionResult;
+    private transformDocument;
+    private transformSelectionSet;
+}
+export {};

package/typings/transforms/TransformCompositeFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+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.js';

package/typings/transforms/TransformEnumValues.d.cts

@@ -0,0 +1,20 @@
+import { GraphQLSchema, ExecutionResult } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { EnumValueTransformer, LeafValueTransformer } from '../types.cjs';
+import { MapLeafValuesTransformationContext } from './MapLeafValues.cjs';
+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<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/typings/transforms/TransformEnumValues.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, ExecutionResult } from '@graphql-tools/graphql';
+import { GraphQLSchema, ExecutionResult } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { EnumValueTransformer, LeafValueTransformer } from '../types.js';

package/typings/transforms/TransformInputObjectFields.d.cts

@@ -0,0 +1,19 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { InputFieldTransformer, InputFieldNodeTransformer, InputObjectNodeTransformer } from '../types.cjs';
+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;
+    private transformedSchema;
+    private mapping;
+    constructor(inputFieldTransformer: InputFieldTransformer, inputFieldNodeTransformer?: InputFieldNodeTransformer, inputObjectNodeTransformer?: InputObjectNodeTransformer);
+    private _getTransformedSchema;
+    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/typings/transforms/TransformInputObjectFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { InputFieldTransformer, InputFieldNodeTransformer, InputObjectNodeTransformer } from '../types.js';

package/typings/transforms/TransformInterfaceFields.d.cts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { FieldTransformer, FieldNodeTransformer } from '../types.cjs';
+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<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    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/typings/transforms/TransformInterfaceFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { FieldTransformer, FieldNodeTransformer } from '../types.js';

package/typings/transforms/TransformObjectFields.d.cts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { FieldTransformer, FieldNodeTransformer } from '../types.cjs';
+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<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    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/typings/transforms/TransformObjectFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { FieldTransformer, FieldNodeTransformer } from '../types.js';

package/typings/transforms/TransformQuery.d.cts

@@ -0,0 +1,27 @@
+import { SelectionSetNode, FragmentDefinitionNode } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext } from '@graphql-tools/delegate';
+export declare type QueryTransformer = <TContext>(selectionSet: SelectionSetNode | undefined, 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>;
+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;
+    private readonly errorPathTransformer;
+    private readonly fragments;
+    constructor({ path, queryTransformer, resultTransformer, errorPathTransformer, fragments, }: {
+        path: Array<string>;
+        queryTransformer: QueryTransformer;
+        resultTransformer?: ResultTransformer;
+        errorPathTransformer?: ErrorPathTransformer;
+        fragments?: Record<string, FragmentDefinitionNode>;
+    });
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionResult;
+    private transformData;
+    private transformErrors;
+}
+export {};

package/typings/transforms/TransformQuery.d.ts

@@ -1,4 +1,4 @@
-import { SelectionSetNode, FragmentDefinitionNode } from '@graphql-tools/graphql';
+import { SelectionSetNode, FragmentDefinitionNode } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
 export declare type QueryTransformer = <TContext>(selectionSet: SelectionSetNode | undefined, fragments: Record<string, FragmentDefinitionNode>, delegationContext: DelegationContext<TContext>, transformationContext: Record<string, any>) => SelectionSetNode;

package/typings/transforms/TransformRootFields.d.cts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { RootFieldTransformer, FieldNodeTransformer } from '../types.cjs';
+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<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    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/typings/transforms/TransformRootFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 import { RootFieldTransformer, FieldNodeTransformer } from '../types.js';

package/typings/transforms/WrapFields.d.cts

@@ -0,0 +1,24 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+interface WrapFieldsTransformationContext {
+    nextIndex: number;
+    paths: Record<string, {
+        pathToField: Array<string>;
+        alias: string;
+    }>;
+}
+export default class WrapFields<TContext extends Record<string, any>> implements Transform<WrapFieldsTransformationContext, TContext> {
+    private readonly outerTypeName;
+    private readonly wrappingFieldNames;
+    private readonly wrappingTypeNames;
+    private readonly numWraps;
+    private readonly fieldNames;
+    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<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionResult;
+}
+export declare function dehoistValue(originalValue: any, context: WrapFieldsTransformationContext): any;
+export {};

package/typings/transforms/WrapFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface WrapFieldsTransformationContext {

package/typings/transforms/WrapQuery.d.cts

@@ -0,0 +1,15 @@
+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;
+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<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionResult;
+}
+export {};

package/typings/transforms/WrapQuery.d.ts

@@ -1,4 +1,4 @@
-import { SelectionNode, SelectionSetNode } from '@graphql-tools/graphql';
+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;

package/typings/transforms/WrapType.d.cts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+interface WrapTypeTransformationContext extends Record<string, any> {
+}
+export default class WrapType<TContext extends Record<string, any> = Record<string, any>> implements Transform<WrapTypeTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(outerTypeName: string, innerTypeName: string, fieldName: string);
+    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/typings/transforms/WrapType.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 interface WrapTypeTransformationContext extends Record<string, any> {

package/typings/transforms/index.d.cts

@@ -0,0 +1,32 @@
+export { default as RenameTypes } from './RenameTypes.cjs';
+export { default as FilterTypes } from './FilterTypes.cjs';
+export { default as RenameRootTypes } from './RenameRootTypes.cjs';
+export { default as TransformCompositeFields } from './TransformCompositeFields.cjs';
+export { default as TransformRootFields } from './TransformRootFields.cjs';
+export { default as RenameRootFields } from './RenameRootFields.cjs';
+export { default as FilterRootFields } from './FilterRootFields.cjs';
+export { default as TransformObjectFields } from './TransformObjectFields.cjs';
+export { default as RenameObjectFields } from './RenameObjectFields.cjs';
+export { default as RenameObjectFieldArguments } from './RenameObjectFieldArguments.cjs';
+export { default as FilterObjectFields } from './FilterObjectFields.cjs';
+export { default as TransformInterfaceFields } from './TransformInterfaceFields.cjs';
+export { default as RenameInterfaceFields } from './RenameInterfaceFields.cjs';
+export { default as FilterInterfaceFields } from './FilterInterfaceFields.cjs';
+export { default as TransformInputObjectFields } from './TransformInputObjectFields.cjs';
+export { default as RenameInputObjectFields } from './RenameInputObjectFields.cjs';
+export { default as FilterInputObjectFields } from './FilterInputObjectFields.cjs';
+export { default as MapLeafValues } from './MapLeafValues.cjs';
+export { default as TransformEnumValues } from './TransformEnumValues.cjs';
+export { default as TransformQuery } from './TransformQuery.cjs';
+export { default as FilterObjectFieldDirectives } from './FilterObjectFieldDirectives.cjs';
+export { default as RemoveObjectFieldDirectives } from './RemoveObjectFieldDirectives.cjs';
+export { default as RemoveObjectFieldsWithDirective } from './RemoveObjectFieldsWithDirective.cjs';
+export { default as RemoveObjectFieldDeprecations } from './RemoveObjectFieldDeprecations.cjs';
+export { default as RemoveObjectFieldsWithDeprecation } from './RemoveObjectFieldsWithDeprecation.cjs';
+export { default as PruneSchema } from './PruneSchema.cjs';
+export { default as WrapType } from './WrapType.cjs';
+export { default as WrapFields } from './WrapFields.cjs';
+export { default as HoistField } from './HoistField.cjs';
+export { default as MapFields } from './MapFields.cjs';
+export { default as WrapQuery } from './WrapQuery.cjs';
+export { default as ExtractField } from './ExtractField.cjs';

package/typings/types.d.cts

@@ -0,0 +1,14 @@
+import { GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinitionNode, SelectionNode, ObjectFieldNode, ObjectValueNode, GraphQLError, GraphQLEnumValueConfig } from 'graphql';
+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 = <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]>;
+export declare type FieldNodeTransformer = (typeName: string, fieldName: string, fieldNode: FieldNode, fragments: Record<string, FragmentDefinitionNode>, transformationContext: Record<string, any>) => Maybe<SelectionNode | Array<SelectionNode>>;
+export declare type LeafValueTransformer = (typeName: string, value: any) => any;
+export declare type DataTransformer = (value: any, transformationContext: Record<string, any>) => any;
+export declare type ObjectValueTransformerMap = Record<string, DataTransformer>;
+export declare type ErrorsTransformer = (errors: ReadonlyArray<GraphQLError> | undefined, transformationContext: Record<string, any>) => Array<GraphQLError> | undefined;

package/typings/types.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinitionNode, SelectionNode, ObjectFieldNode, ObjectValueNode, GraphQLError, GraphQLEnumValueConfig } from '@graphql-tools/graphql';
+import { GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinitionNode, SelectionNode, ObjectFieldNode, ObjectValueNode, GraphQLError, GraphQLEnumValueConfig } from 'graphql';
 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;

package/typings/wrapSchema.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig } from '@graphql-tools/delegate';
+export declare function wrapSchema<TConfig extends Record<string, any> = Record<string, any>>(subschemaConfig: SubschemaConfig<any, any, any, TConfig>): GraphQLSchema;

package/typings/wrapSchema.d.ts

@@ -1,3 +1,3 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig } from '@graphql-tools/delegate';
 export declare function wrapSchema<TConfig extends Record<string, any> = Record<string, any>>(subschemaConfig: SubschemaConfig<any, any, any, TConfig>): GraphQLSchema;