import { type ConstDirectiveNode, type DirectiveDefinitionNode, type DocumentNode, type EnumValueDefinitionNode, type FieldDefinitionNode, type InputValueDefinitionNode, type InterfaceTypeDefinitionNode, Kind, type NamedTypeNode, OperationTypeNode, type TypeDefinitionNode, type TypeExtensionNode } from 'graphql';
import { type EnumTypeNode, type InputObjectTypeNode, type InterfaceTypeNode, type ObjectTypeNode, type ScalarTypeNode, type SchemaNode, type UnionTypeNode } from '../../ast/utils';
import { type ConfigurationData, type Costs, type EntityCacheConfiguration, type EventConfiguration, type FieldWeightConfiguration, type NatsEventType, type RequiredFieldConfiguration } from '../../router-configuration/types';
import { type AuthorizationData, type CompositeOutputData, type ConditionalFieldData, type EntityData, type EntityInterfaceSubgraphData, type EnumDefinitionData, ExtensionType, type FieldData, type InputObjectDefinitionData, type InputValueData, type NodeData, type ObjectDefinitionData, type ParentDefinitionData, type ScalarDefinitionData, type SchemaData, type UnionDefinitionData } from '../../schema-building/types/types';
import { type CompositeOutputNode } from '../../schema-building/ast';
import { type InvalidRootTypeFieldEventsDirectiveData } from '../../errors/types/types';
import { Graph } from '../../resolvability-graph/graph';
import { type Warning } from '../../warnings/types';
import { type NormalizationResult } from '../../normalization/types';
import { type AddInputValueDataByNodeParams, type ComposeDirectiveNode, type ConditionalFieldSetValidationResult, type ExtractDirectiveArgumentDataResult, type FieldSetData, type FieldSetParentResult, type HandleCostDirectiveParams, type HandleListSizeDirectiveParams, type HandleOverrideDirectiveParams, type HandleRequiresScopesDirectiveParams, type HandleSemanticNonNullDirectiveParams, type KeyFieldSetData, type LinkImportData, type RecordDirectiveWeightOnFieldParams, type UpsertInputObjectResult, type ValidateDirectiveParams } from './types/types';
import { type AbstractTypeName, type ArgumentName, type DirectiveName, type FieldName, type SubgraphName, type TypeName } from '../../types/types';
import { type HandleFieldInheritableDirectivesParams, type NormalizationFactoryParams, type NormalizeSubgraphFromStringParams, type NormalizeSubgraphParams, type ValidateOneOfDirectiveParams } from './types/params';
import type { CompositionOptions } from '../../types/params';
import { type SchemaNodeResult } from './types/results';
import { type AddDirectiveArgumentDataByNodeParams, type ExtractDirectiveArgumentDataParams } from '../../directive-definition-data/types/params';
import { type DirectiveArgumentData, type DirectiveDefinitionData } from '../../directive-definition-data/types/types';
export declare function normalizeSubgraphFromString({ noLocation, options, sdlString, }: NormalizeSubgraphFromStringParams): NormalizationResult;
export declare function normalizeSubgraph({ document, internalGraph, options, subgraphName, }: NormalizeSubgraphParams): NormalizationResult;
export declare class NormalizationFactory {
    #private;
    argumentName: string;
    authorizationDataByParentTypeName: Map<string, AuthorizationData>;
    concreteTypeNamesByAbstractTypeName: Map<string, Set<string>>;
    conditionalFieldDataByCoords: Map<string, ConditionalFieldData>;
    configurationDataByTypeName: Map<string, ConfigurationData>;
    costs: Costs;
    customDirectiveDefinitionByName: Map<string, DirectiveDefinitionNode>;
    definedDirectiveNames: Set<string>;
    directiveDefinitionByName: Map<string, DirectiveDefinitionNode>;
    directiveDefinitionDataByName: Map<string, DirectiveDefinitionData>;
    doesParentRequireFetchReasons: boolean;
    edfsDirectiveReferences: Set<string>;
    entityCacheConfigByTypeName: Map<string, EntityCacheConfiguration>;
    errors: Error[];
    entityDataByTypeName: Map<string, EntityData>;
    entityInterfaceDataByTypeName: Map<string, EntityInterfaceSubgraphData>;
    eventsConfigurations: Map<string, EventConfiguration[]>;
    federatedDirectiveDataByName: Map<string, DirectiveDefinitionData>;
    fieldSetDataByTypeName: Map<string, FieldSetData>;
    importDataByDirectiveName: Map<string, LinkImportData>;
    interfaceImplementationTypeNamesByInterfaceTypeName: Map<string, Set<string>>;
    internalGraph: Graph;
    invalidConfigureDescriptionNodeDatas: Array<NodeData>;
    invalidORScopesCoords: Set<string>;
    invalidRepeatedDirectiveNameByCoords: Map<string, Set<string>>;
    isParentObjectExternal: boolean;
    isParentObjectShareable: boolean;
    isSubgraphEventDrivenGraph: boolean;
    isSubgraphVersionTwo: boolean;
    keyFieldSetDatasByTypeName: Map<string, Map<string, KeyFieldSetData>>;
    lastParentNodeKind: Kind;
    lastChildNodeKind: Kind;
    options: CompositionOptions;
    parentTypeNamesWithAuthDirectives: Set<string>;
    keyFieldSetsByEntityTypeNameByFieldCoords: Map<string, Map<string, Set<string>>>;
    keyFieldNamesByParentTypeName: Map<string, Set<string>>;
    fieldCoordsByNamedTypeName: Map<string, Set<string>>;
    operationTypeNodeByTypeName: Map<string, OperationTypeNode>;
    originalParentTypeName: string;
    originalTypeNameByRenamedTypeName: Map<string, string>;
    overriddenFieldNamesByTypeNameByTargetSubgraphName: Map<string, Map<string, Set<string>>>;
    parentDefinitionDataByTypeName: Map<string, ParentDefinitionData>;
    referencedDirectiveNames: Set<string>;
    referencedTypeNames: Set<string>;
    renamedParentTypeName: string;
    schemaData: SchemaData;
    subgraphName: SubgraphName;
    unvalidatedExternalFieldCoords: Set<string>;
    usesEdfsNatsStreamConfiguration: boolean;
    warnings: Array<Warning>;
    constructor({ internalGraph, options, subgraphName }: NormalizationFactoryParams);
    validateArguments(fieldData: FieldData, parentKind: Kind): void;
    isTypeNameRootType(typeName: string): boolean;
    handleFieldInheritableDirectives({ directivesByName, fieldName, inheritedDirectiveNames, parentData, }: HandleFieldInheritableDirectivesParams): void;
    extractDirectives(node: TypeDefinitionNode | TypeExtensionNode | FieldDefinitionNode | InputValueDefinitionNode | EnumValueDefinitionNode | SchemaNode, directivesByName: Map<string, Array<ConstDirectiveNode>>): Map<string, ConstDirectiveNode[]>;
    validateDirective({ data, definitionData, directiveCoords, directiveNode, errorMessages, requiredArgumentNames, }: ValidateDirectiveParams): Array<string>;
    handleComposeDirective(node: ComposeDirectiveNode): void;
    handleExecutableDirectives(): void;
    validateDirectives(data: NodeData | SchemaData, directiveCoords: string): void;
    getNodeExtensionType(isRealExtension: boolean, directivesByName: Map<string, Array<ConstDirectiveNode>>, isRootType?: boolean): ExtensionType;
    setParentDataExtensionType(parentData: ParentDefinitionData, incomingExtensionType: ExtensionType): void;
    extractConfigureDescriptionData(data: NodeData, directiveNode: ConstDirectiveNode): void;
    extractConfigureDescriptionsData(data: NodeData): void;
    extractImplementedInterfaceTypeNames(node: InterfaceTypeNode | ObjectTypeNode, implementedInterfaceTypeNames: Set<AbstractTypeName>): Set<AbstractTypeName>;
    updateCompositeOutputDataByNode(node: CompositeOutputNode, data: CompositeOutputData, extensionType: ExtensionType): void;
    addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames: Set<AbstractTypeName>, concreteTypeName: TypeName): void;
    extractArguments(argumentDataByName: Map<string, InputValueData>, node: FieldDefinitionNode): Map<string, InputValueData>;
    extractDirectiveArgumentData({ argumentNodes, directiveName, errorMessages, }: ExtractDirectiveArgumentDataParams): ExtractDirectiveArgumentDataResult;
    extractDirectiveArgumentCosts(node: DirectiveDefinitionNode): void;
    addDirectiveArgumentDataByNode({ directiveName, node, optionalArgumentNames, requiredArgumentNames, }: AddDirectiveArgumentDataByNodeParams): DirectiveArgumentData;
    addDirectiveDefinitionDataByNode(node: DirectiveDefinitionNode): boolean;
    addFieldDataByNode(fieldDataByName: Map<FieldName, FieldData>, node: FieldDefinitionNode, argumentDataByName: Map<ArgumentName, InputValueData>, directivesByName: Map<DirectiveName, ConstDirectiveNode[]>, inheritedDirectiveNames?: Set<string>): FieldData;
    addInputValueDataByNode({ fieldName, inputValueDataByName, isArgument, node, originalParentTypeName, renamedParentTypeName, }: AddInputValueDataByNodeParams): void;
    upsertInterfaceDataByNode(node: InterfaceTypeNode, isRealExtension?: boolean): void;
    getRenamedRootTypeName(typeName: string): string;
    addInterfaceObjectFieldsByNode(node: ObjectTypeNode): void;
    upsertObjectDataByNode(node: ObjectTypeNode, isRealExtension?: boolean): void;
    upsertEnumDataByNode(node: EnumTypeNode, isRealExtension?: boolean): void;
    upsertInputObjectByNode(node: InputObjectTypeNode, isRealExtension?: boolean): UpsertInputObjectResult;
    upsertScalarByNode(node: ScalarTypeNode, isRealExtension?: boolean): void;
    extractUnionMembers(node: UnionTypeNode, membersByMemberTypeName: Map<string, NamedTypeNode>): Map<string, NamedTypeNode>;
    upsertUnionByNode(node: UnionTypeNode, isRealExtension?: boolean): void;
    extractKeyFieldSets(node: CompositeOutputNode, keyFieldSetDataByFieldSet: Map<string, KeyFieldSetData>): void;
    getFieldSetParent(isProvides: boolean, parentData: CompositeOutputData, fieldName: string, parentTypeName: string): FieldSetParentResult;
    validateConditionalFieldSet(selectionSetParentData: CompositeOutputData, fieldSet: string, directiveFieldName: string, isProvides: boolean, directiveParentTypeName: string): ConditionalFieldSetValidationResult;
    validateProvidesOrRequires(parentData: CompositeOutputData, fieldSetByFieldName: Map<string, string>, isProvides: boolean): RequiredFieldConfiguration[] | undefined;
    validateInterfaceImplementations(data: CompositeOutputData): void;
    handleAuthenticatedDirective(data: NodeData | SchemaData, parentTypeName: string): void;
    handleOverrideDirective({ data, directiveCoords, errorMessages, targetSubgraphName }: HandleOverrideDirectiveParams): void;
    handleSemanticNonNullDirective({ data, directiveNode, errorMessages }: HandleSemanticNonNullDirectiveParams): void;
    getOrCreateFieldWeight(typeName: TypeName, fieldName: FieldName): FieldWeightConfiguration;
    handleCostDirective({ data, directiveCoords, directiveNode, errorMessages }: HandleCostDirectiveParams): void;
    recordDirectiveWeightOnField({ data, definitionData, directiveName, directiveNode, }: RecordDirectiveWeightOnFieldParams): void;
    handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages }: HandleListSizeDirectiveParams): void;
    extractRequiredScopes({ directiveCoords, orScopes, requiredScopes }: HandleRequiresScopesDirectiveParams): void;
    getKafkaPublishConfiguration(directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    getKafkaSubscribeConfiguration(directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    getNatsPublishAndRequestConfiguration(eventType: NatsEventType, directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    getNatsSubscribeConfiguration(directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    getRedisPublishConfiguration(directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    getRedisSubscribeConfiguration(directive: ConstDirectiveNode, argumentDataByArgumentName: Map<string, InputValueData>, fieldName: string, errorMessages: string[]): EventConfiguration | undefined;
    validateSubscriptionFilterDirectiveLocation(node: FieldDefinitionNode): void;
    extractEventDirectivesToConfiguration(node: FieldDefinitionNode, argumentDataByArgumentName: Map<string, InputValueData>): void;
    getValidEventsDirectiveNamesForOperationTypeNode(operationTypeNode: OperationTypeNode): Set<string>;
    getOperationTypeNodeForRootTypeName(parentTypeName: string): OperationTypeNode | undefined;
    validateEventDrivenRootType(data: ObjectDefinitionData, invalidEventsDirectiveDataByRootFieldPath: Map<string, InvalidRootTypeFieldEventsDirectiveData>, invalidResponseTypeStringByRootFieldPath: Map<string, string>, invalidResponseTypeNameByMutationPath: Map<string, string>): void;
    validateEventDrivenKeyDefinition(typeName: string, invalidKeyFieldSetsByEntityTypeName: Map<string, Array<string>>): void;
    validateEventDrivenObjectFields(fieldDataByFieldName: Map<string, FieldData>, keyFieldNames: Set<string>, nonExternalKeyFieldNameByFieldPath: Map<string, string>, nonKeyFieldNameByFieldPath: Map<string, string>): void;
    isEdfsPublishResultValid(): boolean;
    isNatsStreamConfigurationInputObjectValid(streamConfigurationInputData: ParentDefinitionData): boolean;
    validateEventDrivenSubgraph(): void;
    validateUnionMembers(data: UnionDefinitionData): void;
    addConcreteTypeNamesForUnion(node: UnionTypeNode): void;
    addValidKeyFieldSetConfigurations(): void;
    getValidFlattenedDirectiveArray(directivesByName: Map<string, ConstDirectiveNode[]>, directiveCoords: string, removeInheritedDirectives?: boolean): ConstDirectiveNode[];
    getEnumNodeByData(enumDefinitionData: EnumDefinitionData): import("../../schema-building/ast").MutableEnumNode;
    getInputObjectNodeByData(inputObjectDefinitionData: InputObjectDefinitionData): import("../../schema-building/ast").MutableInputObjectNode;
    getCompositeOutputNodeByData(compositeOutputData: CompositeOutputData): ObjectTypeNode | InterfaceTypeDefinitionNode;
    getScalarNodeByData(scalarDefinitionData: ScalarDefinitionData): import("../../schema-building/ast").MutableScalarNode;
    schemaNodeFromData(schemaData: SchemaData): SchemaNodeResult;
    getUnionNodeByData(unionDefinitionData: UnionDefinitionData): import("../../schema-building/ast").MutableUnionNode;
    evaluateExternalKeyFields(): void;
    addValidConditionalFieldSetConfigurations(): void;
    extractEntityCacheDirective({ directivesByName, name: typeName }: ObjectDefinitionData): void;
    extractCacheInvalidateConfig(fieldData: FieldData): boolean;
    extractCachePopulateConfig(fieldData: FieldData): boolean;
    addFieldNamesToConfigurationData(fieldDataByFieldName: Map<string, FieldData>, configurationData: ConfigurationData): void;
    validateOneOfDirective({ data, requiredFieldNames }: ValidateOneOfDirectiveParams): boolean;
    handleFieldCacheDirectives(data: FieldData): void;
    normalize(document: DocumentNode): NormalizationResult;
}