@wundergraph/composition 0.26.2 → 0.27.0

package/dist/errors/errors.js

@@ -1,8 +1,133 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unexpectedParentKindErrorMessage = exports.federationFactoryInitializationFatalError = exports.subgraphValidationFailureError = exports.invalidConfigurationResultFatalError = exports.invalidKeyFatalError = exports.unexpectedTypeNodeKindFatalError = exports.unexpectedDirectiveLocationError = exports.fieldTypeMergeFatalError = exports.incompatibleObjectExtensionOrphanBaseTypeError = exports.incompatibleParentKindMergeError = exports.incompatibleParentKindFatalError = exports.unexpectedKindFatalError = exports.maximumTypeNestingExceededError = exports.invalidKeyDirectivesError = exports.invalidKeyDirectiveArgumentErrorMessage = exports.invalidDirectiveArgumentTypeErrorMessage = exports.duplicateDirectiveArgumentDefinitionsErrorMessage = exports.unexpectedDirectiveArgumentErrorMessage = exports.undefinedRequiredArgumentsErrorMessage = exports.unexpectedDirectiveArgumentsErrorMessage = exports.invalidDirectiveLocationErrorMessage = exports.invalidDirectiveError = exports.duplicateUnionMemberError = exports.invalidRepeatedFederatedDirectiveErrorMessage = exports.invalidRepeatedDirectiveErrorMessage = exports.undefinedTypeError = exports.unresolvableFieldError = exports.undefinedDirectiveErrorMessage = exports.invalidFieldShareabilityError = exports.operationDefinitionError = exports.noDefinedUnionMembersError = exports.noBaseTypeExtensionError = exports.duplicateOperationTypeDefinitionError = exports.duplicateTypeDefinitionError = exports.duplicateValueExtensionError = exports.duplicateUnionMemberExtensionError = exports.duplicateInterfaceError = exports.duplicateInterfaceExtensionError = exports.duplicateEnumValueDefinitionError = exports.duplicateDirectiveDefinitionError = exports.duplicateFieldDefinitionError = exports.invalidSubgraphNamesError = exports.incompatibleExtensionKindsError = exports.incompatibleSharedEnumError = exports.incompatibleInputValueDefaultValuesError = exports.incompatibleChildTypesError = exports.incompatibleInputValueDefaultValueTypeError = exports.incompatibleArgumentTypesError = exports.incompatibleExtensionError = exports.minimumSubgraphRequirementError = void 0;
-exports.invalidKeyFieldSetsEventDrivenErrorMessage = exports.invalidNatsStreamInputFieldsErrorMessage = exports.invalidNatsStreamInputErrorMessage = exports.invalidRootTypeFieldResponseTypesEventDrivenErrorMessage = exports.invalidEventDrivenMutationResponseTypeErrorMessage = exports.invalidRootTypeFieldEventsDirectivesErrorMessage = exports.invalidEventDrivenGraphError = exports.orScopesLimitError = exports.undefinedEntityInterfaceImplementationsError = exports.equivalentSourceAndTargetOverrideErrorMessage = exports.allChildDefinitionsAreInaccessibleError = exports.noFieldDefinitionsError = exports.duplicateOverriddenFieldsError = exports.duplicateOverriddenFieldErrorMessage = exports.invalidSelectionOnUnionErrorMessage = exports.invalidInlineFragmentTypeConditionErrorMessage = exports.invalidInlineFragmentTypeConditionTypeErrorMessage = exports.unknownInlineFragmentTypeConditionErrorMessage = exports.inlineFragmentWithoutTypeConditionErrorMessage = exports.invalidInlineFragmentTypeErrorMessage = exports.unknownProvidesEntityErrorMessage = exports.invalidConfigurationDataErrorMessage = exports.duplicateFieldInFieldSetErrorMessage = exports.invalidProvidesOrRequiresDirectivesError = exports.argumentsInKeyFieldSetErrorMessage = exports.unexpectedArgumentErrorMessage = exports.undefinedObjectLikeParentError = exports.unparsableFieldSetSelectionErrorMessage = exports.unparsableFieldSetErrorMessage = exports.undefinedFieldInFieldSetErrorMessage = exports.invalidSelectionSetDefinitionErrorMessage = exports.invalidSelectionSetErrorMessage = exports.unknownTypeInFieldSetErrorMessage = exports.abstractTypeInKeyFieldSetErrorMessage = exports.inlineFragmentInFieldSetErrorMessage = exports.expectedEntityError = exports.noConcreteTypesForAbstractTypeError = exports.unexpectedObjectResponseType = exports.inaccessibleQueryRootTypeError = exports.noQueryRootTypeError = exports.invalidArgumentsError = exports.duplicateArgumentsError = exports.invalidRequiredInputValueError = exports.invalidInterfaceImplementationError = exports.subgraphInvalidSyntaxError = exports.invalidRootTypeDefinitionError = exports.invalidOperationTypeDefinitionError = exports.invalidSubgraphNameErrorMessage = exports.subgraphValidationError = exports.unexpectedParentKindForChildError = void 0;
-exports.nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage = exports.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage = exports.invalidSubscriptionFieldConditionFieldPathFieldErrorMessage = exports.undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage = exports.invalidSubscriptionFieldConditionFieldPathParentErrorMessage = exports.invalidSubscriptionFieldConditionFieldPathErrorMessage = exports.unknownFieldSubgraphNameError = exports.subscriptionFieldConditionEmptyValuesArrayErrorMessage = exports.subscriptionFieldConditionInvalidValuesArrayErrorMessage = exports.subscriptionFieldConditionInvalidInputFieldErrorMessage = exports.invalidInputFieldTypeErrorMessage = exports.subscriptionFilterArrayConditionInvalidLengthErrorMessage = exports.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage = exports.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage = exports.subscriptionFilterConditionInvalidInputFieldErrorMessage = exports.subscriptionFilterConditionInvalidInputFieldNumberErrorMessage = exports.subscriptionFilterConditionDepthExceededErrorMessage = exports.invalidSubscriptionFilterDirectiveError = exports.invalidSubscriptionFilterLocationError = exports.invalidRootTypeError = exports.invalidUnionMemberTypeError = exports.inaccessibleRequiredArgumentError = exports.invalidReferencesOfInaccessibleTypeError = exports.invalidEventDirectiveError = exports.invalidEventProviderIdErrorMessage = exports.invalidEventSubjectsItemErrorMessage = exports.invalidEventSubjectsErrorMessage = exports.invalidEventSubjectErrorMessage = exports.selfImplementationError = exports.invalidImplementedTypeError = exports.invalidEdfsDirectiveName = exports.invalidNatsStreamConfigurationDefinitionErrorMessage = exports.undefinedNatsStreamConfigurationInputErrorMessage = exports.invalidEdfsPublishResultObjectErrorMessage = exports.nonKeyComposingObjectTypeNamesEventDrivenErrorMessage = exports.nonEntityObjectExtensionsEventDrivenErrorMessage = exports.nonKeyFieldNamesEventDrivenErrorMessage = exports.nonExternalKeyFieldNamesEventDrivenErrorMessage = void 0;
+exports.invalidEventProviderIdErrorMessage = exports.invalidNatsStreamConfigurationDefinitionErrorMessage = exports.undefinedNatsStreamConfigurationInputErrorMessage = exports.invalidEdfsPublishResultObjectErrorMessage = exports.invalidNatsStreamInputErrorMessage = exports.inlineFragmentInFieldSetErrorMessage = exports.inaccessibleQueryRootTypeError = exports.noQueryRootTypeError = exports.federationFactoryInitializationFatalError = exports.subgraphValidationFailureError = exports.minimumSubgraphRequirementError = void 0;
+exports.incompatibleExtensionError = incompatibleExtensionError;
+exports.incompatibleArgumentTypesError = incompatibleArgumentTypesError;
+exports.incompatibleInputValueDefaultValueTypeError = incompatibleInputValueDefaultValueTypeError;
+exports.incompatibleChildTypesError = incompatibleChildTypesError;
+exports.incompatibleInputValueDefaultValuesError = incompatibleInputValueDefaultValuesError;
+exports.incompatibleSharedEnumError = incompatibleSharedEnumError;
+exports.incompatibleExtensionKindsError = incompatibleExtensionKindsError;
+exports.invalidSubgraphNamesError = invalidSubgraphNamesError;
+exports.duplicateFieldDefinitionError = duplicateFieldDefinitionError;
+exports.duplicateDirectiveDefinitionError = duplicateDirectiveDefinitionError;
+exports.duplicateEnumValueDefinitionError = duplicateEnumValueDefinitionError;
+exports.duplicateInterfaceExtensionError = duplicateInterfaceExtensionError;
+exports.duplicateInterfaceError = duplicateInterfaceError;
+exports.duplicateUnionMemberExtensionError = duplicateUnionMemberExtensionError;
+exports.duplicateValueExtensionError = duplicateValueExtensionError;
+exports.duplicateTypeDefinitionError = duplicateTypeDefinitionError;
+exports.duplicateOperationTypeDefinitionError = duplicateOperationTypeDefinitionError;
+exports.noBaseTypeExtensionError = noBaseTypeExtensionError;
+exports.noDefinedUnionMembersError = noDefinedUnionMembersError;
+exports.operationDefinitionError = operationDefinitionError;
+exports.invalidFieldShareabilityError = invalidFieldShareabilityError;
+exports.undefinedDirectiveErrorMessage = undefinedDirectiveErrorMessage;
+exports.unresolvableFieldError = unresolvableFieldError;
+exports.undefinedTypeError = undefinedTypeError;
+exports.invalidRepeatedDirectiveErrorMessage = invalidRepeatedDirectiveErrorMessage;
+exports.invalidRepeatedFederatedDirectiveErrorMessage = invalidRepeatedFederatedDirectiveErrorMessage;
+exports.duplicateUnionMemberError = duplicateUnionMemberError;
+exports.invalidDirectiveError = invalidDirectiveError;
+exports.invalidDirectiveLocationErrorMessage = invalidDirectiveLocationErrorMessage;
+exports.unexpectedDirectiveArgumentsErrorMessage = unexpectedDirectiveArgumentsErrorMessage;
+exports.undefinedRequiredArgumentsErrorMessage = undefinedRequiredArgumentsErrorMessage;
+exports.unexpectedDirectiveArgumentErrorMessage = unexpectedDirectiveArgumentErrorMessage;
+exports.duplicateDirectiveArgumentDefinitionsErrorMessage = duplicateDirectiveArgumentDefinitionsErrorMessage;
+exports.invalidDirectiveArgumentTypeErrorMessage = invalidDirectiveArgumentTypeErrorMessage;
+exports.invalidKeyDirectiveArgumentErrorMessage = invalidKeyDirectiveArgumentErrorMessage;
+exports.invalidKeyDirectivesError = invalidKeyDirectivesError;
+exports.maximumTypeNestingExceededError = maximumTypeNestingExceededError;
+exports.unexpectedKindFatalError = unexpectedKindFatalError;
+exports.incompatibleParentKindFatalError = incompatibleParentKindFatalError;
+exports.incompatibleParentKindMergeError = incompatibleParentKindMergeError;
+exports.incompatibleObjectExtensionOrphanBaseTypeError = incompatibleObjectExtensionOrphanBaseTypeError;
+exports.fieldTypeMergeFatalError = fieldTypeMergeFatalError;
+exports.unexpectedDirectiveLocationError = unexpectedDirectiveLocationError;
+exports.unexpectedTypeNodeKindFatalError = unexpectedTypeNodeKindFatalError;
+exports.invalidKeyFatalError = invalidKeyFatalError;
+exports.invalidConfigurationResultFatalError = invalidConfigurationResultFatalError;
+exports.unexpectedParentKindErrorMessage = unexpectedParentKindErrorMessage;
+exports.unexpectedParentKindForChildError = unexpectedParentKindForChildError;
+exports.subgraphValidationError = subgraphValidationError;
+exports.invalidSubgraphNameErrorMessage = invalidSubgraphNameErrorMessage;
+exports.invalidOperationTypeDefinitionError = invalidOperationTypeDefinitionError;
+exports.invalidRootTypeDefinitionError = invalidRootTypeDefinitionError;
+exports.subgraphInvalidSyntaxError = subgraphInvalidSyntaxError;
+exports.invalidInterfaceImplementationError = invalidInterfaceImplementationError;
+exports.invalidRequiredInputValueError = invalidRequiredInputValueError;
+exports.duplicateArgumentsError = duplicateArgumentsError;
+exports.invalidArgumentsError = invalidArgumentsError;
+exports.unexpectedObjectResponseType = unexpectedObjectResponseType;
+exports.noConcreteTypesForAbstractTypeError = noConcreteTypesForAbstractTypeError;
+exports.expectedEntityError = expectedEntityError;
+exports.abstractTypeInKeyFieldSetErrorMessage = abstractTypeInKeyFieldSetErrorMessage;
+exports.unknownTypeInFieldSetErrorMessage = unknownTypeInFieldSetErrorMessage;
+exports.invalidSelectionSetErrorMessage = invalidSelectionSetErrorMessage;
+exports.invalidSelectionSetDefinitionErrorMessage = invalidSelectionSetDefinitionErrorMessage;
+exports.undefinedFieldInFieldSetErrorMessage = undefinedFieldInFieldSetErrorMessage;
+exports.unparsableFieldSetErrorMessage = unparsableFieldSetErrorMessage;
+exports.unparsableFieldSetSelectionErrorMessage = unparsableFieldSetSelectionErrorMessage;
+exports.undefinedObjectLikeParentError = undefinedObjectLikeParentError;
+exports.unexpectedArgumentErrorMessage = unexpectedArgumentErrorMessage;
+exports.argumentsInKeyFieldSetErrorMessage = argumentsInKeyFieldSetErrorMessage;
+exports.invalidProvidesOrRequiresDirectivesError = invalidProvidesOrRequiresDirectivesError;
+exports.duplicateFieldInFieldSetErrorMessage = duplicateFieldInFieldSetErrorMessage;
+exports.invalidConfigurationDataErrorMessage = invalidConfigurationDataErrorMessage;
+exports.unknownProvidesEntityErrorMessage = unknownProvidesEntityErrorMessage;
+exports.invalidInlineFragmentTypeErrorMessage = invalidInlineFragmentTypeErrorMessage;
+exports.inlineFragmentWithoutTypeConditionErrorMessage = inlineFragmentWithoutTypeConditionErrorMessage;
+exports.unknownInlineFragmentTypeConditionErrorMessage = unknownInlineFragmentTypeConditionErrorMessage;
+exports.invalidInlineFragmentTypeConditionTypeErrorMessage = invalidInlineFragmentTypeConditionTypeErrorMessage;
+exports.invalidInlineFragmentTypeConditionErrorMessage = invalidInlineFragmentTypeConditionErrorMessage;
+exports.invalidSelectionOnUnionErrorMessage = invalidSelectionOnUnionErrorMessage;
+exports.duplicateOverriddenFieldErrorMessage = duplicateOverriddenFieldErrorMessage;
+exports.duplicateOverriddenFieldsError = duplicateOverriddenFieldsError;
+exports.noFieldDefinitionsError = noFieldDefinitionsError;
+exports.allChildDefinitionsAreInaccessibleError = allChildDefinitionsAreInaccessibleError;
+exports.equivalentSourceAndTargetOverrideErrorMessage = equivalentSourceAndTargetOverrideErrorMessage;
+exports.undefinedEntityInterfaceImplementationsError = undefinedEntityInterfaceImplementationsError;
+exports.orScopesLimitError = orScopesLimitError;
+exports.invalidEventDrivenGraphError = invalidEventDrivenGraphError;
+exports.invalidRootTypeFieldEventsDirectivesErrorMessage = invalidRootTypeFieldEventsDirectivesErrorMessage;
+exports.invalidEventDrivenMutationResponseTypeErrorMessage = invalidEventDrivenMutationResponseTypeErrorMessage;
+exports.invalidRootTypeFieldResponseTypesEventDrivenErrorMessage = invalidRootTypeFieldResponseTypesEventDrivenErrorMessage;
+exports.invalidNatsStreamInputFieldsErrorMessage = invalidNatsStreamInputFieldsErrorMessage;
+exports.invalidKeyFieldSetsEventDrivenErrorMessage = invalidKeyFieldSetsEventDrivenErrorMessage;
+exports.nonExternalKeyFieldNamesEventDrivenErrorMessage = nonExternalKeyFieldNamesEventDrivenErrorMessage;
+exports.nonKeyFieldNamesEventDrivenErrorMessage = nonKeyFieldNamesEventDrivenErrorMessage;
+exports.nonEntityObjectExtensionsEventDrivenErrorMessage = nonEntityObjectExtensionsEventDrivenErrorMessage;
+exports.nonKeyComposingObjectTypeNamesEventDrivenErrorMessage = nonKeyComposingObjectTypeNamesEventDrivenErrorMessage;
+exports.invalidEdfsDirectiveName = invalidEdfsDirectiveName;
+exports.invalidImplementedTypeError = invalidImplementedTypeError;
+exports.selfImplementationError = selfImplementationError;
+exports.invalidEventSubjectErrorMessage = invalidEventSubjectErrorMessage;
+exports.invalidEventSubjectsErrorMessage = invalidEventSubjectsErrorMessage;
+exports.invalidEventSubjectsItemErrorMessage = invalidEventSubjectsItemErrorMessage;
+exports.invalidEventDirectiveError = invalidEventDirectiveError;
+exports.invalidReferencesOfInaccessibleTypeError = invalidReferencesOfInaccessibleTypeError;
+exports.inaccessibleRequiredArgumentError = inaccessibleRequiredArgumentError;
+exports.invalidUnionMemberTypeError = invalidUnionMemberTypeError;
+exports.invalidRootTypeError = invalidRootTypeError;
+exports.invalidSubscriptionFilterLocationError = invalidSubscriptionFilterLocationError;
+exports.invalidSubscriptionFilterDirectiveError = invalidSubscriptionFilterDirectiveError;
+exports.subscriptionFilterConditionDepthExceededErrorMessage = subscriptionFilterConditionDepthExceededErrorMessage;
+exports.subscriptionFilterConditionInvalidInputFieldNumberErrorMessage = subscriptionFilterConditionInvalidInputFieldNumberErrorMessage;
+exports.subscriptionFilterConditionInvalidInputFieldErrorMessage = subscriptionFilterConditionInvalidInputFieldErrorMessage;
+exports.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage = subscriptionFilterConditionInvalidInputFieldTypeErrorMessage;
+exports.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage = subscriptionFilterArrayConditionInvalidItemTypeErrorMessage;
+exports.subscriptionFilterArrayConditionInvalidLengthErrorMessage = subscriptionFilterArrayConditionInvalidLengthErrorMessage;
+exports.invalidInputFieldTypeErrorMessage = invalidInputFieldTypeErrorMessage;
+exports.subscriptionFieldConditionInvalidInputFieldErrorMessage = subscriptionFieldConditionInvalidInputFieldErrorMessage;
+exports.subscriptionFieldConditionInvalidValuesArrayErrorMessage = subscriptionFieldConditionInvalidValuesArrayErrorMessage;
+exports.subscriptionFieldConditionEmptyValuesArrayErrorMessage = subscriptionFieldConditionEmptyValuesArrayErrorMessage;
+exports.unknownFieldSubgraphNameError = unknownFieldSubgraphNameError;
+exports.invalidSubscriptionFieldConditionFieldPathErrorMessage = invalidSubscriptionFieldConditionFieldPathErrorMessage;
+exports.invalidSubscriptionFieldConditionFieldPathParentErrorMessage = invalidSubscriptionFieldConditionFieldPathParentErrorMessage;
+exports.undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage = undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage;
+exports.invalidSubscriptionFieldConditionFieldPathFieldErrorMessage = invalidSubscriptionFieldConditionFieldPathFieldErrorMessage;
+exports.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage = inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage;
+exports.nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage = nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage;
 const utils_1 = require("../ast/utils");
 const graphql_1 = require("graphql");
 const utils_2 = require("../utils/utils");
@@ -13,22 +138,18 @@ function incompatibleExtensionError(typeName, baseKind, extensionKind) {
     return new Error(`Extension error:\n Incompatible types: ` +
         `"${typeName}" is type "${baseKind}", but an extension of the same name is type "${extensionKind}.`);
 }
-exports.incompatibleExtensionError = incompatibleExtensionError;
 function incompatibleArgumentTypesError(argName, hostPath, expectedType, actualType) {
     return new Error(`Incompatible types when merging two instances of argument "${argName}" on path "${hostPath}":\n` +
         ` Expected type "${expectedType}" but received "${actualType}"`);
 }
-exports.incompatibleArgumentTypesError = incompatibleArgumentTypesError;
 function incompatibleInputValueDefaultValueTypeError(prefix, path, typeString, defaultValue) {
     return new Error(`The ${prefix} of type "${typeString}" defined on path "${path}" is` +
         ` incompatible with the default value of "${defaultValue}".`);
 }
-exports.incompatibleInputValueDefaultValueTypeError = incompatibleInputValueDefaultValueTypeError;
 function incompatibleChildTypesError(childPath, expectedType, actualType) {
     return new Error(`Incompatible types when merging two instances of "${childPath}":\n` +
         ` Expected type "${expectedType}" but received "${actualType}"`);
 }
-exports.incompatibleChildTypesError = incompatibleChildTypesError;
 function incompatibleInputValueDefaultValuesError(prefix, path, subgraphNames, expectedDefaultValue, actualDefaultValue) {
     return new Error(`Expected the ${prefix} defined on path "${path}" to define the default value "${expectedDefaultValue}".\n"` +
         `However, the default value "${actualDefaultValue}" is defined in the following subgraph` +
@@ -38,17 +159,14 @@ function incompatibleInputValueDefaultValuesError(prefix, path, subgraphNames, e
         `"\n` +
         'If an instance defines a default value, that default value must be consistently defined across all subgraphs.');
 }
-exports.incompatibleInputValueDefaultValuesError = incompatibleInputValueDefaultValuesError;
 function incompatibleSharedEnumError(parentName) {
     return new Error(`Enum "${parentName}" was used as both an input and output but was inconsistently defined across inclusive subgraphs.`);
 }
-exports.incompatibleSharedEnumError = incompatibleSharedEnumError;
 // The @extends directive means a TypeDefinitionNode is possible
 function incompatibleExtensionKindsError(node, existingKind) {
     const name = node.kind === graphql_1.Kind.SCHEMA_EXTENSION ? 'schema' : node.name.value;
     return new Error(`Expected extension "${name}" to be type ${existingKind} but received ${node.kind}.`);
 }
-exports.incompatibleExtensionKindsError = incompatibleExtensionKindsError;
 function invalidSubgraphNamesError(names, invalidNameErrorMessages) {
     let message = 'Subgraphs to be federated must each have a unique, non-empty name.';
     if (names.length > 0) {
@@ -59,56 +177,43 @@ function invalidSubgraphNamesError(names, invalidNameErrorMessages) {
     }
     return new Error(message);
 }
-exports.invalidSubgraphNamesError = invalidSubgraphNamesError;
 function duplicateFieldDefinitionError(fieldName, typeName) {
     return new Error(`Extension error:\n Field "${fieldName}" already exists on type "${typeName}".`);
 }
-exports.duplicateFieldDefinitionError = duplicateFieldDefinitionError;
 function duplicateDirectiveDefinitionError(directiveName) {
     return new Error(`The directive "${directiveName}" has already been defined.`);
 }
-exports.duplicateDirectiveDefinitionError = duplicateDirectiveDefinitionError;
 function duplicateEnumValueDefinitionError(valueName, typeName) {
     return new Error(`Extension error:\n Value "${valueName}" already exists on enum "${typeName}".`);
 }
-exports.duplicateEnumValueDefinitionError = duplicateEnumValueDefinitionError;
 function duplicateInterfaceExtensionError(interfaceName, typeName) {
     return new Error(`Extension error:\n Interface "${interfaceName}" is already implemented by type "${typeName}".`);
 }
-exports.duplicateInterfaceExtensionError = duplicateInterfaceExtensionError;
 function duplicateInterfaceError(interfaceName, typeName) {
     return new Error(`Interface "${interfaceName}" can only be defined on type "${typeName}" once.`);
 }
-exports.duplicateInterfaceError = duplicateInterfaceError;
 function duplicateUnionMemberExtensionError(memberName, typeName) {
     return new Error(`Extension error:\n Member "${memberName}" already exists on union "${typeName}".`);
 }
-exports.duplicateUnionMemberExtensionError = duplicateUnionMemberExtensionError;
 function duplicateValueExtensionError(parentType, typeName, childName) {
     return new Error(`Extension error:\n` +
         ` More than one extension attempts to extend ${parentType} "${typeName}" with the value "${childName}".`);
 }
-exports.duplicateValueExtensionError = duplicateValueExtensionError;
 function duplicateTypeDefinitionError(type, typeName) {
     return new Error(`The ${type} "${typeName}" can only be defined once.`);
 }
-exports.duplicateTypeDefinitionError = duplicateTypeDefinitionError;
 function duplicateOperationTypeDefinitionError(operationTypeName, newTypeName, oldTypeName) {
     return new Error(`The operation type "${operationTypeName}" cannot be defined as "${newTypeName}" because it has already been defined as "${oldTypeName}".`);
 }
-exports.duplicateOperationTypeDefinitionError = duplicateOperationTypeDefinitionError;
 function noBaseTypeExtensionError(typeName) {
     return new Error(`Extension error:\n Could not extend the type "${typeName}" because no base definition exists.`);
 }
-exports.noBaseTypeExtensionError = noBaseTypeExtensionError;
 function noDefinedUnionMembersError(unionTypeName, extension = false) {
     return new Error(`The union ` + (extension ? 'extension' : '') + ` "${unionTypeName}" must define at least one union member.`);
 }
-exports.noDefinedUnionMembersError = noDefinedUnionMembersError;
 function operationDefinitionError(typeName, operationType, actualType) {
     return new Error(`Expected the response type "${typeName}" for operation "${operationType}" to be type object but received "${actualType}.`);
 }
-exports.operationDefinitionError = operationDefinitionError;
 function invalidFieldShareabilityError(objectData, invalidFieldNames) {
     const parentTypeName = objectData.name;
     const errorMessages = [];
@@ -138,12 +243,10 @@ function invalidFieldShareabilityError(objectData, invalidFieldNames) {
     return new Error(`The object "${parentTypeName}" defines the same fields in multiple subgraphs without the "@shareable" directive:` +
         `${errorMessages.join('\n')}`);
 }
-exports.invalidFieldShareabilityError = invalidFieldShareabilityError;
 function undefinedDirectiveErrorMessage(directiveName, hostPath) {
     return (`The directive "${directiveName}" is declared on "${hostPath}",` +
         ` but the directive is not defined in the schema.`);
 }
-exports.undefinedDirectiveErrorMessage = undefinedDirectiveErrorMessage;
 function unresolvableFieldError(rootTypeFieldData, fieldName, fieldSubgraphs, unresolvablePath, parentTypeName) {
     const fieldPath = `${parentTypeName}.${fieldName}`;
     return new Error(`The path "${unresolvablePath}" cannot be resolved because:\n` +
@@ -171,36 +274,29 @@ function unresolvableFieldError(rootTypeFieldData, fieldName, fieldSubgraphs, un
         `     ${rootTypeFieldData.fieldName}: ${rootTypeFieldData.fieldTypeNodeString} @shareable\n` +
         `   }`);
 }
-exports.unresolvableFieldError = unresolvableFieldError;
 function undefinedTypeError(typeName) {
     return new Error(` The type "${typeName}" was referenced in the schema, but it was never defined.`);
 }
-exports.undefinedTypeError = undefinedTypeError;
 function invalidRepeatedDirectiveErrorMessage(directiveName, hostPath) {
     return (`The definition for the directive "${directiveName}" does not define it as repeatable, ` +
         `but the same directive is declared more than once on type "${hostPath}".`);
 }
-exports.invalidRepeatedDirectiveErrorMessage = invalidRepeatedDirectiveErrorMessage;
 function invalidRepeatedFederatedDirectiveErrorMessage(directiveName, hostPath) {
     return new Error(`The definition for the directive "${directiveName}" does not define it as repeatable,` +
         ` but the directive has been declared on more than one instance of the type "${hostPath}".`);
 }
-exports.invalidRepeatedFederatedDirectiveErrorMessage = invalidRepeatedFederatedDirectiveErrorMessage;
 function duplicateUnionMemberError(memberTypeName, unionTypeName) {
     return new Error(`Member "${memberTypeName}" must only be defined on union "${unionTypeName}" once.`);
 }
-exports.duplicateUnionMemberError = duplicateUnionMemberError;
 function invalidDirectiveError(directiveName, hostPath, errorMessages) {
     return new Error(`The directive "${directiveName}" declared on "${hostPath}" is invalid for the following reason` +
         (errorMessages.length > 1 ? 's:\n' : ':\n') +
         errorMessages.join('\n'));
 }
-exports.invalidDirectiveError = invalidDirectiveError;
 function invalidDirectiveLocationErrorMessage(hostPath, kind, directiveName) {
     return (` "${hostPath}" is type "${kind}", but the directive "${directiveName}" ` +
         `does not define "${(0, utils_1.nodeKindToDirectiveLocation)(kind)}" as a valid location.`);
 }
-exports.invalidDirectiveLocationErrorMessage = invalidDirectiveLocationErrorMessage;
 function unexpectedDirectiveArgumentsErrorMessage(directive, hostPath) {
     const directiveName = directive.name.value;
     const argumentNumber = directive.arguments?.length || 1; // should never be less than 1
@@ -208,7 +304,6 @@ function unexpectedDirectiveArgumentsErrorMessage(directive, hostPath) {
         ` However, the same directive declared on "${hostPath}" defines ${argumentNumber} argument` +
         (argumentNumber > 1 ? 's.' : '.'));
 }
-exports.unexpectedDirectiveArgumentsErrorMessage = unexpectedDirectiveArgumentsErrorMessage;
 function undefinedRequiredArgumentsErrorMessage(directiveName, hostPath, requiredArguments, missingRequiredArguments = []) {
     let message = ` The definition for the directive "${directiveName}" defines the following ` +
         requiredArguments.length +
@@ -228,7 +323,6 @@ function undefinedRequiredArgumentsErrorMessage(directiveName, hostPath, require
         missingRequiredArguments.join(string_constants_1.QUOTATION_JOIN) +
         `".`);
 }
-exports.undefinedRequiredArgumentsErrorMessage = undefinedRequiredArgumentsErrorMessage;
 function unexpectedDirectiveArgumentErrorMessage(directiveName, argumentNames) {
     return (` The definition for the directive "${directiveName}" does not define the following provided argument` +
         (argumentNames.length > 1 ? 's' : '') +
@@ -236,7 +330,6 @@ function unexpectedDirectiveArgumentErrorMessage(directiveName, argumentNames) {
         argumentNames.join(string_constants_1.QUOTATION_JOIN) +
         `".`);
 }
-exports.unexpectedDirectiveArgumentErrorMessage = unexpectedDirectiveArgumentErrorMessage;
 function duplicateDirectiveArgumentDefinitionsErrorMessage(directiveName, hostPath, argumentNames) {
     return (` The directive "${directiveName}" that is declared on "${hostPath}" defines the following argument` +
         (argumentNames.length > 1 ? 's' : '') +
@@ -244,97 +337,78 @@ function duplicateDirectiveArgumentDefinitionsErrorMessage(directiveName, hostPa
         argumentNames.join(string_constants_1.QUOTATION_JOIN) +
         `"`);
 }
-exports.duplicateDirectiveArgumentDefinitionsErrorMessage = duplicateDirectiveArgumentDefinitionsErrorMessage;
 function invalidDirectiveArgumentTypeErrorMessage(required, argumentName, expectedKind, actualKind) {
     return (` The ${required ? 'required ' : ''}argument "${argumentName} must be type` +
         ` "${expectedKind}" and not type "${actualKind}".`);
 }
-exports.invalidDirectiveArgumentTypeErrorMessage = invalidDirectiveArgumentTypeErrorMessage;
 function invalidKeyDirectiveArgumentErrorMessage(directiveKind) {
     return ` The required argument named "fields" must be type "String" and not type "${directiveKind}".`;
 }
-exports.invalidKeyDirectiveArgumentErrorMessage = invalidKeyDirectiveArgumentErrorMessage;
 function invalidKeyDirectivesError(parentTypeName, errorMessages) {
     return new Error(`The entity "${parentTypeName}" defines the following invalid "key" directive` +
         (errorMessages.length > 1 ? 's' : '') +
         `:\n` +
         errorMessages.join('\n'));
 }
-exports.invalidKeyDirectivesError = invalidKeyDirectivesError;
 function maximumTypeNestingExceededError(path) {
     return new Error(` The type defined at path "${path}" has more than ${integer_constants_1.MAXIMUM_TYPE_NESTING} layers of nesting,` +
         ` or there is a cyclical error.`);
 }
-exports.maximumTypeNestingExceededError = maximumTypeNestingExceededError;
 function unexpectedKindFatalError(typeName) {
     return new Error(`Fatal: Unexpected type for "${typeName}"`);
 }
-exports.unexpectedKindFatalError = unexpectedKindFatalError;
 function incompatibleParentKindFatalError(parentTypeName, expectedKind, actualKind) {
     return new Error(`Fatal: Expected "${parentTypeName}" to be type ${(0, utils_2.kindToTypeString)(expectedKind)}` +
         ` but received "${(0, utils_2.kindToTypeString)(actualKind)}".`);
 }
-exports.incompatibleParentKindFatalError = incompatibleParentKindFatalError;
 function incompatibleParentKindMergeError(parentTypeName, expectedTypeString, actualTypeString) {
     return new Error(` When merging types, expected "${parentTypeName}" to be type ${expectedTypeString} but received "${actualTypeString}".`);
 }
-exports.incompatibleParentKindMergeError = incompatibleParentKindMergeError;
 function incompatibleObjectExtensionOrphanBaseTypeError(parentTypeName, actualTypeString) {
     return new Error(` When merging the object extension orphan "${parentTypeName}", expected an existing object base type` +
         ` but received "${actualTypeString}".`);
 }
-exports.incompatibleObjectExtensionOrphanBaseTypeError = incompatibleObjectExtensionOrphanBaseTypeError;
 function fieldTypeMergeFatalError(fieldName) {
     return new Error(`Fatal: Unsuccessfully merged the cross-subgraph types of field "${fieldName}"` +
         ` without producing a type error object.`);
 }
-exports.fieldTypeMergeFatalError = fieldTypeMergeFatalError;
 function unexpectedDirectiveLocationError(locationName) {
     return new Error(`Fatal: Unknown directive location "${locationName}".`);
 }
-exports.unexpectedDirectiveLocationError = unexpectedDirectiveLocationError;
 function unexpectedTypeNodeKindFatalError(typePath) {
     return new Error(`Fatal: Expected all constituent types at path "${typePath}" to be one of the following: ` +
         `"LIST_TYPE", "NAMED_TYPE", or "NON_NULL_TYPE".`);
 }
-exports.unexpectedTypeNodeKindFatalError = unexpectedTypeNodeKindFatalError;
 function invalidKeyFatalError(key, mapName) {
     return new Error(`Fatal: Expected key "${key}" to exist in the map "${mapName}".`);
 }
-exports.invalidKeyFatalError = invalidKeyFatalError;
 function invalidConfigurationResultFatalError(fieldPath) {
     return new Error(`Fatal: Expected either errors or configurations for the path ${fieldPath}" but received neither".`);
 }
-exports.invalidConfigurationResultFatalError = invalidConfigurationResultFatalError;
 exports.subgraphValidationFailureError = new Error(` Fatal: Subgraph validation did not return a valid AST.`);
 exports.federationFactoryInitializationFatalError = new Error('Fatal: FederationFactory was unsuccessfully initialized.');
 function unexpectedParentKindErrorMessage(parentTypeName, expectedTypeString, actualTypeString) {
     return ` Expected "${parentTypeName}" to be type ${expectedTypeString} but received "${actualTypeString}".`;
 }
-exports.unexpectedParentKindErrorMessage = unexpectedParentKindErrorMessage;
 function unexpectedParentKindForChildError(parentTypeName, expectedTypeString, actualTypeString, childName, childTypeString) {
     return new Error(` Expected "${parentTypeName}" to be type ${expectedTypeString} but received "${actualTypeString}"` +
         ` when handling child "${childName}" of type "${childTypeString}".`);
 }
-exports.unexpectedParentKindForChildError = unexpectedParentKindForChildError;
 function subgraphValidationError(subgraphName, errors) {
     return new Error(`The subgraph "${subgraphName}" could not be federated for the following reason` +
         (errors.length > 1 ? 's' : '') +
         `:\n` +
         errors.map((error) => error.message).join('\n'));
 }
-exports.subgraphValidationError = subgraphValidationError;
 function invalidSubgraphNameErrorMessage(index, newName) {
     return (`The ${(0, utils_2.numberToOrdinal)(index + 1)} subgraph in the array did not define a name.` +
         ` Consequently, any further errors will temporarily identify this subgraph as "${newName}".`);
 }
-exports.invalidSubgraphNameErrorMessage = invalidSubgraphNameErrorMessage;
 function invalidOperationTypeDefinitionError(existingOperationType, typeName, newOperationType) {
     return new Error(`The schema definition defines the "${existingOperationType}" operation as type "${typeName}".` +
         ` However, "${typeName}" was also used for the "${newOperationType}" operation.\n` +
         ` If explicitly defined, each operation type must be a unique and valid Object type.`);
 }
-exports.invalidOperationTypeDefinitionError = invalidOperationTypeDefinitionError;
 function invalidRootTypeDefinitionError(operationType, typeName, defaultTypeName) {
     return new Error(`The schema definition defines the "${operationType}" operation as type "${typeName}".` +
         ` However, the schema also defines another type named "${defaultTypeName}",` +
@@ -342,7 +416,6 @@ function invalidRootTypeDefinitionError(operationType, typeName, defaultTypeName
         `For federation, it is only possible to use the default root types names ("Mutation", "Query", "Subscription") as` +
         ` operation definitions. No other definitions with these default root type names are valid.`);
 }
-exports.invalidRootTypeDefinitionError = invalidRootTypeDefinitionError;
 function subgraphInvalidSyntaxError(error) {
     let message = `The subgraph has syntax errors and could not be parsed.`;
     if (error) {
@@ -350,7 +423,6 @@ function subgraphInvalidSyntaxError(error) {
     }
     return new Error(message);
 }
-exports.subgraphInvalidSyntaxError = subgraphInvalidSyntaxError;
 function invalidInterfaceImplementationError(parentTypeName, parentTypeString, implementationErrorsByInterfaceTypeName) {
     const messages = [];
     for (const [interfaceName, implementationErrors] of implementationErrorsByInterfaceTypeName) {
@@ -411,7 +483,6 @@ function invalidInterfaceImplementationError(parentTypeName, parentTypeString, i
     return new Error(`The ${parentTypeString} "${parentTypeName}" has the following interface implementation errors:\n` +
         messages.join('\n'));
 }
-exports.invalidInterfaceImplementationError = invalidInterfaceImplementationError;
 function invalidRequiredInputValueError(typeString, path, errors, isArgument = true) {
     const inputValueTypeString = isArgument ? string_constants_1.ARGUMENT : string_constants_1.INPUT_FIELD;
     let message = `The ${typeString} "${path}" could not be federated because:\n`;
@@ -432,7 +503,6 @@ function invalidRequiredInputValueError(typeString, path, errors, isArgument = t
     }
     return new Error(message);
 }
-exports.invalidRequiredInputValueError = invalidRequiredInputValueError;
 function duplicateArgumentsError(fieldPath, duplicatedArguments) {
     return new Error(`The field "${fieldPath}" is invalid because:\n` +
         ` The following argument` +
@@ -441,7 +511,6 @@ function duplicateArgumentsError(fieldPath, duplicatedArguments) {
         duplicatedArguments.join(string_constants_1.QUOTATION_JOIN) +
         `"\n`);
 }
-exports.duplicateArgumentsError = duplicateArgumentsError;
 function invalidArgumentsError(fieldPath, invalidArguments) {
     let message = `The field "${fieldPath}" is invalid because:\n` +
         ` The named type (root type) of an input must be on of Enum, Input Object, or Scalar type.` +
@@ -455,7 +524,6 @@ function invalidArgumentsError(fieldPath, invalidArguments) {
     }
     return new Error(message);
 }
-exports.invalidArgumentsError = invalidArgumentsError;
 exports.noQueryRootTypeError = new Error(`A valid federated graph must have at least one accessible query root type field.\n` +
     ` For example:\n` +
     `  type Query {\n` +
@@ -467,17 +535,14 @@ function unexpectedObjectResponseType(fieldPath, actualTypeString) {
     return new Error(`Expected the path "${fieldPath}" to have the response type` +
         ` Enum, Interface, Object, Scalar, or Union but received ${actualTypeString}.`);
 }
-exports.unexpectedObjectResponseType = unexpectedObjectResponseType;
 function noConcreteTypesForAbstractTypeError(typeString, abstractTypeName) {
     return new Error(`Expected ${typeString} "${abstractTypeName}" to define at least one ` +
         (typeString === string_constants_1.UNION ? 'member' : 'object that implements the interface') +
         ` but received none`);
 }
-exports.noConcreteTypesForAbstractTypeError = noConcreteTypesForAbstractTypeError;
 function expectedEntityError(typeName) {
     return new Error(`Expected object "${typeName}" to define a "key" directive, but it defines no directives.`);
 }
-exports.expectedEntityError = expectedEntityError;
 exports.inlineFragmentInFieldSetErrorMessage = ` Inline fragments are not currently supported within a FieldSet argument.`;
 function abstractTypeInKeyFieldSetErrorMessage(fieldSet, fieldPath, abstractTypeName, abstractTypeString) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
@@ -485,30 +550,25 @@ function abstractTypeInKeyFieldSetErrorMessage(fieldSet, fieldPath, abstractType
         `  Fields that return abstract types (interfaces and unions)` +
         ` cannot be included in the FieldSet of "@key" directives.`);
 }
-exports.abstractTypeInKeyFieldSetErrorMessage = abstractTypeInKeyFieldSetErrorMessage;
 function unknownTypeInFieldSetErrorMessage(fieldSet, fieldPath, responseTypeName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" returns the unknown type "${responseTypeName}".`);
 }
-exports.unknownTypeInFieldSetErrorMessage = unknownTypeInFieldSetErrorMessage;
 function invalidSelectionSetErrorMessage(fieldSet, fieldPath, fieldTypeName, fieldTypeString) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" returns "${fieldTypeName}", which is type "${fieldTypeString}".\n` +
         ` Types such as "${fieldTypeString}" that define fields` +
         ` must define a selection set with at least one field selection.`);
 }
-exports.invalidSelectionSetErrorMessage = invalidSelectionSetErrorMessage;
 function invalidSelectionSetDefinitionErrorMessage(fieldSet, fieldPath, fieldTypeName, fieldTypeString) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" returns "${fieldTypeName}", which is type "${fieldTypeString}".\n` +
         `  Types such as "${fieldTypeString}" that do not define fields cannot define a selection set.`);
 }
-exports.invalidSelectionSetDefinitionErrorMessage = invalidSelectionSetDefinitionErrorMessage;
 function undefinedFieldInFieldSetErrorMessage(fieldSet, parentTypeName, fieldName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${parentTypeName}" does not define a field named "${fieldName}".`);
 }
-exports.undefinedFieldInFieldSetErrorMessage = undefinedFieldInFieldSetErrorMessage;
 function unparsableFieldSetErrorMessage(fieldSet, error) {
     let message = ` The following FieldSet is invalid:\n "${fieldSet}"\n` + `  The FieldSet could not be parsed.`;
     if (error) {
@@ -516,74 +576,61 @@ function unparsableFieldSetErrorMessage(fieldSet, error) {
     }
     return message;
 }
-exports.unparsableFieldSetErrorMessage = unparsableFieldSetErrorMessage;
 function unparsableFieldSetSelectionErrorMessage(fieldSet, fieldName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because the selection set defined on "${fieldName}" could not be parsed.`);
 }
-exports.unparsableFieldSetSelectionErrorMessage = unparsableFieldSetSelectionErrorMessage;
 function undefinedObjectLikeParentError(parentTypeName) {
     return new Error(` Expected an object/interface or object/interface extension named "${parentTypeName}" to exist.`);
 }
-exports.undefinedObjectLikeParentError = undefinedObjectLikeParentError;
 function unexpectedArgumentErrorMessage(fieldSet, fieldPath, argumentName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" does not define an argument named "${argumentName}".`);
 }
-exports.unexpectedArgumentErrorMessage = unexpectedArgumentErrorMessage;
 function argumentsInKeyFieldSetErrorMessage(fieldSet, fieldPath) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines arguments.\n` +
         `  Fields that define arguments cannot be included in the FieldSet of @key directives.`);
 }
-exports.argumentsInKeyFieldSetErrorMessage = argumentsInKeyFieldSetErrorMessage;
 function invalidProvidesOrRequiresDirectivesError(directiveName, errorMessages) {
     return new Error(`The following "${directiveName}" directive` +
         (errorMessages.length > 1 ? 's are' : ' is') +
         ` invalid:\n` +
         errorMessages.join(`\n`));
 }
-exports.invalidProvidesOrRequiresDirectivesError = invalidProvidesOrRequiresDirectivesError;
 function duplicateFieldInFieldSetErrorMessage(fieldSet, fieldPath) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" was included in the FieldSet more than once.`);
 }
-exports.duplicateFieldInFieldSetErrorMessage = duplicateFieldInFieldSetErrorMessage;
 function invalidConfigurationDataErrorMessage(typeName, fieldName, fieldSet) {
     return (` Expected ConfigurationData to exist for type "${typeName}" when adding field "${fieldName}"` +
         `  while validating FieldSet "${fieldSet}".`);
 }
-exports.invalidConfigurationDataErrorMessage = invalidConfigurationDataErrorMessage;
 function unknownProvidesEntityErrorMessage(fieldPath, responseType) {
     return (` A @provides directive is declared on "${fieldPath}".\n` +
         ` However, the response type "${responseType}" object or object extension definition was not found.`);
 }
-exports.unknownProvidesEntityErrorMessage = unknownProvidesEntityErrorMessage;
 function invalidInlineFragmentTypeErrorMessage(fieldSet, fieldPath, typeConditionName, parentTypeName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines an inline fragment with the type condition "${typeConditionName}".\n` +
         `  However, "${parentTypeName}" is not an abstract (interface or union) type.\n` +
         `  Consequently, the only valid type condition would be "${parentTypeName}".`);
 }
-exports.invalidInlineFragmentTypeErrorMessage = invalidInlineFragmentTypeErrorMessage;
 function inlineFragmentWithoutTypeConditionErrorMessage(fieldSet, fieldPath) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines an inline fragment without a type condition.`);
 }
-exports.inlineFragmentWithoutTypeConditionErrorMessage = inlineFragmentWithoutTypeConditionErrorMessage;
 function unknownInlineFragmentTypeConditionErrorMessage(fieldSet, fieldPath, typeConditionName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines an inline fragment` +
         ` with the unknown type condition "${typeConditionName}".`);
 }
-exports.unknownInlineFragmentTypeConditionErrorMessage = unknownInlineFragmentTypeConditionErrorMessage;
 function invalidInlineFragmentTypeConditionTypeErrorMessage(fieldSet, fieldPath, typeConditionName, typeConditionTypeString) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines an inline fragment with the type condition "${typeConditionName}",` +
         ` which is type "${typeConditionTypeString}".\n` +
         `  However, either an "interface" or "object" type was expected.`);
 }
-exports.invalidInlineFragmentTypeConditionTypeErrorMessage = invalidInlineFragmentTypeConditionTypeErrorMessage;
 function invalidInlineFragmentTypeConditionErrorMessage(fieldSet, fieldPath, typeConditionName, parentTypeString, parentTypeName) {
     let message = ` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" defines an inline fragment with the type condition "${typeConditionName}".\n`;
@@ -592,19 +639,16 @@ function invalidInlineFragmentTypeConditionErrorMessage(fieldSet, fieldPath, typ
     }
     return message + `  However, "${typeConditionName}" is not a member of the union "${parentTypeName}".`;
 }
-exports.invalidInlineFragmentTypeConditionErrorMessage = invalidInlineFragmentTypeConditionErrorMessage;
 function invalidSelectionOnUnionErrorMessage(fieldSet, fieldPath, responseTypeName) {
     return (` The following FieldSet is invalid:\n "${fieldSet}"\n` +
         `  This is because "${fieldPath}" returns "${responseTypeName}", which is type "union".\n` +
         `  Consequently, an inline fragment is required to make a selection on one of the union's members.`);
 }
-exports.invalidSelectionOnUnionErrorMessage = invalidSelectionOnUnionErrorMessage;
 function duplicateOverriddenFieldErrorMessage(fieldPath, subgraphNames) {
     return (` The field "${fieldPath}" declares an @override directive in the following subgraphs: "` +
         subgraphNames.join(string_constants_1.QUOTATION_JOIN) +
         `".`);
 }
-exports.duplicateOverriddenFieldErrorMessage = duplicateOverriddenFieldErrorMessage;
 function duplicateOverriddenFieldsError(errorMessages) {
     return new Error(`The @override directive must only be declared on one single instance of a field.` +
         ` However, an @override directive was declared on more than one instance of the following field` +
@@ -613,19 +657,15 @@ function duplicateOverriddenFieldsError(errorMessages) {
         errorMessages.join(string_constants_1.QUOTATION_JOIN) +
         `".\n`);
 }
-exports.duplicateOverriddenFieldsError = duplicateOverriddenFieldsError;
 function noFieldDefinitionsError(typeString, typeName) {
     return new Error(`The ${typeString} "${typeName}" is invalid because it does not define any fields.`);
 }
-exports.noFieldDefinitionsError = noFieldDefinitionsError;
 function allChildDefinitionsAreInaccessibleError(typeString, typeName, childType) {
     return new Error(`The ${typeString} "${typeName}" is invalid because all its ${childType} definitions are declared "@inaccessible".`);
 }
-exports.allChildDefinitionsAreInaccessibleError = allChildDefinitionsAreInaccessibleError;
 function equivalentSourceAndTargetOverrideErrorMessage(subgraphName, hostPath) {
     return `Cannot override field "${hostPath}" because the source and target subgraph names are both "${subgraphName}"`;
 }
-exports.equivalentSourceAndTargetOverrideErrorMessage = equivalentSourceAndTargetOverrideErrorMessage;
 function undefinedEntityInterfaceImplementationsError(invalidEntityInterfacesByTypeName, entityInterfaceFederationDataByTypeName) {
     let message = `Federation was unsuccessful because any one subgraph that defines a specific entity interface` +
         ` must also define each and every entity object that implements that entity interface.\n`;
@@ -650,7 +690,6 @@ function undefinedEntityInterfaceImplementationsError(invalidEntityInterfacesByT
     }
     return new Error(message);
 }
-exports.undefinedEntityInterfaceImplementationsError = undefinedEntityInterfaceImplementationsError;
 function orScopesLimitError(maxOrScopes, hostPaths) {
     return new Error(`The maximum number of OR scopes that can be defined by @requiresScopes on a single field is ${maxOrScopes}.` +
         ` However, the following path` +
@@ -659,7 +698,6 @@ function orScopesLimitError(maxOrScopes, hostPaths) {
         hostPaths.join(string_constants_1.QUOTATION_JOIN) +
         `"\nIf you require more, please contact support.`);
 }
-exports.orScopesLimitError = orScopesLimitError;
 function invalidEventDrivenGraphError(errorMessages) {
     return new Error(`An "Event Driven" graph—a subgraph that defines event driven directives—must not define any resolvers.\n` +
         `Consequently, any "@key" definitions must also include the "resolvable: false" argument.\n` +
@@ -667,7 +705,6 @@ function invalidEventDrivenGraphError(errorMessages) {
         ` declared "@external" are permitted.\n` +
         errorMessages.join('\n'));
 }
-exports.invalidEventDrivenGraphError = invalidEventDrivenGraphError;
 function invalidRootTypeFieldEventsDirectivesErrorMessage(invalidEventsDirectiveDataByRootFieldPath) {
     let message = ` Root type fields defined in an Event Driven graph must define a valid events` +
         ` directive:\n  Mutation type fields must define either a edfs publish or request directive."\n` +
@@ -690,7 +727,6 @@ function invalidRootTypeFieldEventsDirectivesErrorMessage(invalidEventsDirective
     }
     return message;
 }
-exports.invalidRootTypeFieldEventsDirectivesErrorMessage = invalidRootTypeFieldEventsDirectivesErrorMessage;
 function invalidEventDrivenMutationResponseTypeErrorMessage(invalidResponseTypeStringByMutationPath) {
     let message = ` Mutation type fields defined in an Event Driven graph must return the non-nullable type` +
         ` "edfs__PublishResult!", which has the following definition:\n  type edfs__PublishResult {\n` +
@@ -702,7 +738,6 @@ function invalidEventDrivenMutationResponseTypeErrorMessage(invalidResponseTypeS
     }
     return message;
 }
-exports.invalidEventDrivenMutationResponseTypeErrorMessage = invalidEventDrivenMutationResponseTypeErrorMessage;
 function invalidRootTypeFieldResponseTypesEventDrivenErrorMessage(invalidResponseTypeStringByRootFieldPath) {
     let message = ` The named response type of root type fields defined in an Event Driven graph must be a` +
         ` non-nullable, non-list named type that is either an entity, an interface implemented by` +
@@ -714,7 +749,6 @@ function invalidRootTypeFieldResponseTypesEventDrivenErrorMessage(invalidRespons
     }
     return message;
 }
-exports.invalidRootTypeFieldResponseTypesEventDrivenErrorMessage = invalidRootTypeFieldResponseTypesEventDrivenErrorMessage;
 exports.invalidNatsStreamInputErrorMessage = `The "streamConfiguration" argument must be a valid input object with the following form:\n` +
     `  input edfs__NatsStreamConfiguration {\n    consumerName: String!\n    streamName: String!\n  }`;
 function invalidNatsStreamInputFieldsErrorMessage(missingRequiredFieldNames, duplicateRequiredFieldNames, invalidRequiredFieldNames, invalidFieldNames) {
@@ -755,7 +789,6 @@ function invalidNatsStreamInputFieldsErrorMessage(missingRequiredFieldNames, dup
             errorMessages.join(`\n  `);
     return message;
 }
-exports.invalidNatsStreamInputFieldsErrorMessage = invalidNatsStreamInputFieldsErrorMessage;
 function invalidKeyFieldSetsEventDrivenErrorMessage(invalidKeyFieldSetsByEntityTypeName = new Map()) {
     let message = '';
     for (const [typeName, keyFieldSets] of invalidKeyFieldSetsByEntityTypeName) {
@@ -769,7 +802,6 @@ function invalidKeyFieldSetsEventDrivenErrorMessage(invalidKeyFieldSetsByEntityT
     }
     return message;
 }
-exports.invalidKeyFieldSetsEventDrivenErrorMessage = invalidKeyFieldSetsEventDrivenErrorMessage;
 function nonExternalKeyFieldNamesEventDrivenErrorMessage(nonExternalKeyFieldNameByFieldPath) {
     let message = ` The following field` +
         (nonExternalKeyFieldNameByFieldPath.size > 1 ? 's' : '') +
@@ -779,7 +811,6 @@ function nonExternalKeyFieldNamesEventDrivenErrorMessage(nonExternalKeyFieldName
     }
     return message;
 }
-exports.nonExternalKeyFieldNamesEventDrivenErrorMessage = nonExternalKeyFieldNamesEventDrivenErrorMessage;
 function nonKeyFieldNamesEventDrivenErrorMessage(nonKeyFieldNameByFieldPath) {
     let message = ` The following field` +
         (nonKeyFieldNameByFieldPath.size > 1 ? 's are' : ' is') +
@@ -789,7 +820,6 @@ function nonKeyFieldNamesEventDrivenErrorMessage(nonKeyFieldNameByFieldPath) {
     }
     return message;
 }
-exports.nonKeyFieldNamesEventDrivenErrorMessage = nonKeyFieldNamesEventDrivenErrorMessage;
 function nonEntityObjectExtensionsEventDrivenErrorMessage(typeNames) {
     return (` Only root types and entities (objects that define one or more primary keys with the "@key" directive) may` +
         ` be defined as object extensions in an Event Driven graph. Consequently, the following object extension` +
@@ -799,7 +829,6 @@ function nonEntityObjectExtensionsEventDrivenErrorMessage(typeNames) {
         typeNames.join(string_constants_1.QUOTATION_JOIN) +
         `"\n`);
 }
-exports.nonEntityObjectExtensionsEventDrivenErrorMessage = nonEntityObjectExtensionsEventDrivenErrorMessage;
 function nonKeyComposingObjectTypeNamesEventDrivenErrorMessage(typeNames) {
     return (` Only object definitions whose fields compose part of a "@key" directive's FieldSet may be defined in an` +
         ` Event Driven graph. Consequently, the following object type definition` +
@@ -808,7 +837,6 @@ function nonKeyComposingObjectTypeNamesEventDrivenErrorMessage(typeNames) {
         typeNames.join(string_constants_1.QUOTATION_JOIN) +
         `"\n`);
 }
-exports.nonKeyComposingObjectTypeNamesEventDrivenErrorMessage = nonKeyComposingObjectTypeNamesEventDrivenErrorMessage;
 exports.invalidEdfsPublishResultObjectErrorMessage = ` The object "edfs__PublishResult" that was defined in the Event Driven graph is invalid and must instead have` +
     ` the following definition:\n  type edfs__PublishResult {\n   success: Boolean!\n  }`;
 exports.undefinedNatsStreamConfigurationInputErrorMessage = ` The input object "edfs__NatsStreamConfiguration" must be defined in the event-driven graph to satisfy the` +
@@ -820,7 +848,6 @@ exports.invalidNatsStreamConfigurationDefinitionErrorMessage = ` The input objec
 function invalidEdfsDirectiveName(directiveName) {
     return new Error(`Could not retrieve definition for Event-Driven Federated Subscription directive "${directiveName}".`);
 }
-exports.invalidEdfsDirectiveName = invalidEdfsDirectiveName;
 function invalidImplementedTypeError(typeName, invalidImplementationTypeStringByTypeName) {
     let message = ` Only interfaces can be implemented. However, the type "${typeName}" attempts to implement` +
         ` the following invalid type` +
@@ -831,24 +858,19 @@ function invalidImplementedTypeError(typeName, invalidImplementationTypeStringBy
     }
     return new Error(message);
 }
-exports.invalidImplementedTypeError = invalidImplementedTypeError;
 function selfImplementationError(typeName) {
     return new Error(` The interface "${typeName}" must not implement itself.`);
 }
-exports.selfImplementationError = selfImplementationError;
 function invalidEventSubjectErrorMessage(argumentName) {
     return `The "${argumentName}" argument must be string with a minimum length of one.`;
 }
-exports.invalidEventSubjectErrorMessage = invalidEventSubjectErrorMessage;
 function invalidEventSubjectsErrorMessage(argumentName) {
     return `The "${argumentName}" argument must be a list of strings.`;
 }
-exports.invalidEventSubjectsErrorMessage = invalidEventSubjectsErrorMessage;
 function invalidEventSubjectsItemErrorMessage(argumentName) {
     return (`Each item in the "${argumentName}" argument list must be a string with a minimum length of one.` +
         ` However, at least one value provided in the list was invalid.`);
 }
-exports.invalidEventSubjectsItemErrorMessage = invalidEventSubjectsItemErrorMessage;
 exports.invalidEventProviderIdErrorMessage = `If explicitly defined, the "providerId" argument must be a string with a minimum length of one.`;
 function invalidEventDirectiveError(directiveName, fieldPath, errorMessages) {
     return new Error(`The event directive "${directiveName}" declared on "${fieldPath}" is invalid for the following` +
@@ -857,35 +879,29 @@ function invalidEventDirectiveError(directiveName, fieldPath, errorMessages) {
         `:\n ` +
         errorMessages.join(`\n `));
 }
-exports.invalidEventDirectiveError = invalidEventDirectiveError;
 function invalidReferencesOfInaccessibleTypeError(typeString, typeName, invalidPaths) {
     return new Error(`The ${typeString} "${typeName}" is declared @inaccessible; however, the ${typeString} is still referenced at` +
         ` the following paths:\n "` +
         invalidPaths.join(string_constants_1.QUOTATION_JOIN) +
         `"\n`);
 }
-exports.invalidReferencesOfInaccessibleTypeError = invalidReferencesOfInaccessibleTypeError;
 function inaccessibleRequiredArgumentError(argumentName, argumentPath, fieldName) {
     return new Error(`The argument "${argumentName}" on path "${argumentPath}" is declared @inaccessible;` +
         ` however, it is a required argument for field "${fieldName}".`);
 }
-exports.inaccessibleRequiredArgumentError = inaccessibleRequiredArgumentError;
 function invalidUnionMemberTypeError(typeName, invalidMembers) {
     return new Error(` The union "${typeName}" defines the following member` +
         (invalidMembers.length > 1 ? `s that are not object types` : ` that is not an object type`) +
         `:\n  ` +
         invalidMembers.join(`\n  `));
 }
-exports.invalidUnionMemberTypeError = invalidUnionMemberTypeError;
 function invalidRootTypeError(typeName) {
     return new Error(`Expected type "${typeName}" to be a root type but could not find its respective OperationTypeNode.`);
 }
-exports.invalidRootTypeError = invalidRootTypeError;
 function invalidSubscriptionFilterLocationError(path) {
     return new Error(`The "@${string_constants_1.SUBSCRIPTION_FILTER}" directive must only be defined on a subscription root field, but it was` +
         ` defined on the path "${path}".`);
 }
-exports.invalidSubscriptionFilterLocationError = invalidSubscriptionFilterLocationError;
 function invalidSubscriptionFilterDirectiveError(fieldPath, errorMessages) {
     return new Error(`The "@${string_constants_1.SUBSCRIPTION_FILTER}" directive defined on path "${fieldPath}" is invalid for the` +
         ` following reason` +
@@ -893,29 +909,24 @@ function invalidSubscriptionFilterDirectiveError(fieldPath, errorMessages) {
         `:\n` +
         errorMessages.join(`\n`));
 }
-exports.invalidSubscriptionFilterDirectiveError = invalidSubscriptionFilterDirectiveError;
 function subscriptionFilterConditionDepthExceededErrorMessage(inputPath) {
     return (` The input path "${inputPath}" exceeds the maximum depth of ${integer_constants_1.MAX_SUBSCRIPTION_FILTER_DEPTH}` +
         ` for any one filter condition.\n` +
         ` If you require a larger maximum depth, please contact support.`);
 }
-exports.subscriptionFilterConditionDepthExceededErrorMessage = subscriptionFilterConditionDepthExceededErrorMessage;
 const subscriptionFilterConditionFieldsString = ` Each "${string_constants_1.SUBSCRIPTION_FILTER_CONDITION}" input object must define exactly one of the following` +
     ` input value fields: "${string_constants_1.AND_UPPER}", "${string_constants_1.IN_UPPER}", "${string_constants_1.NOT_UPPER}", or "${string_constants_1.OR_UPPER}".\n`;
 function subscriptionFilterConditionInvalidInputFieldNumberErrorMessage(inputPath, fieldNumber) {
     return subscriptionFilterConditionFieldsString + ` However, input path "${inputPath}" defines ${fieldNumber} fields.`;
 }
-exports.subscriptionFilterConditionInvalidInputFieldNumberErrorMessage = subscriptionFilterConditionInvalidInputFieldNumberErrorMessage;
 function subscriptionFilterConditionInvalidInputFieldErrorMessage(inputPath, invalidFieldName) {
     return (subscriptionFilterConditionFieldsString +
         ` However, input path "${inputPath}" defines the invalid input value field "${invalidFieldName}".`);
 }
-exports.subscriptionFilterConditionInvalidInputFieldErrorMessage = subscriptionFilterConditionInvalidInputFieldErrorMessage;
 function subscriptionFilterConditionInvalidInputFieldTypeErrorMessage(inputPath, expectedTypeString, actualTypeString) {
     return (` Expected the value of input path "${inputPath}" to be type "${expectedTypeString}"` +
         ` but received type "${actualTypeString}"`);
 }
-exports.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage = subscriptionFilterConditionInvalidInputFieldTypeErrorMessage;
 const subscriptionFilterConditionArrayString = ` An AND or OR input field defined on a "${string_constants_1.SUBSCRIPTION_FILTER_CONDITION}" should define a list of 1–5` +
     ` nested conditions.\n`;
 function subscriptionFilterArrayConditionInvalidItemTypeErrorMessage(inputPath, invalidIndices) {
@@ -928,17 +939,14 @@ function subscriptionFilterArrayConditionInvalidItemTypeErrorMessage(inputPath,
         ` not type "object": ` +
         invalidIndices.join(`, `));
 }
-exports.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage = subscriptionFilterArrayConditionInvalidItemTypeErrorMessage;
 function subscriptionFilterArrayConditionInvalidLengthErrorMessage(inputPath, actualLength) {
     return (subscriptionFilterConditionArrayString +
         ` However, the list defined on input path "${inputPath}" has a length of ${actualLength}.`);
 }
-exports.subscriptionFilterArrayConditionInvalidLengthErrorMessage = subscriptionFilterArrayConditionInvalidLengthErrorMessage;
 function invalidInputFieldTypeErrorMessage(inputPath, expectedTypeString, actualTypeString) {
     return (` Expected the input path "${inputPath}" to be type "${expectedTypeString}"` +
         ` but received "${actualTypeString}".`);
 }
-exports.invalidInputFieldTypeErrorMessage = invalidInputFieldTypeErrorMessage;
 function subscriptionFieldConditionInvalidInputFieldErrorMessage(inputPath, missingFieldNames, duplicatedFieldNames, invalidFieldNames, fieldErrorMessages) {
     let message = ` Each "${string_constants_1.SUBSCRIPTION_FIELD_CONDITION}" input object must only define the following two` +
         ` input value fields: "${string_constants_1.FIELD_PATH}" and "${string_constants_1.VALUES}".\n However, input path "${inputPath}" is invalid because:`;
@@ -971,7 +979,6 @@ function subscriptionFieldConditionInvalidInputFieldErrorMessage(inputPath, miss
     }
     return message;
 }
-exports.subscriptionFieldConditionInvalidInputFieldErrorMessage = subscriptionFieldConditionInvalidInputFieldErrorMessage;
 const subscriptionFieldConditionValuesString = ` A "${string_constants_1.SUBSCRIPTION_FIELD_CONDITION}" input object must define a "values" input value field` +
     ` with a list of at least one valid "${string_constants_1.SUBSCRIPTION_FILTER_VALUE}" kind (boolean, enum, float, int, null, or string).\n`;
 function subscriptionFieldConditionInvalidValuesArrayErrorMessage(inputPath, invalidIndices) {
@@ -984,30 +991,24 @@ function subscriptionFieldConditionInvalidValuesArrayErrorMessage(inputPath, inv
         ` not a valid "${string_constants_1.SUBSCRIPTION_FILTER_VALUE}": ` +
         invalidIndices.join(`, `));
 }
-exports.subscriptionFieldConditionInvalidValuesArrayErrorMessage = subscriptionFieldConditionInvalidValuesArrayErrorMessage;
 function subscriptionFieldConditionEmptyValuesArrayErrorMessage(inputPath) {
     return subscriptionFieldConditionValuesString + ` However, the list defined on input path "${inputPath}" is empty.`;
 }
-exports.subscriptionFieldConditionEmptyValuesArrayErrorMessage = subscriptionFieldConditionEmptyValuesArrayErrorMessage;
 function unknownFieldSubgraphNameError(fieldPath) {
     return new Error(` Field "${fieldPath}" defined no subgraph names.`);
 }
-exports.unknownFieldSubgraphNameError = unknownFieldSubgraphNameError;
 function invalidSubscriptionFieldConditionFieldPathErrorMessage(inputPath, conditionFieldPath) {
     return ` Input path "${inputPath}" defines the value "${conditionFieldPath}", which is not a period (.) delimited field path.`;
 }
-exports.invalidSubscriptionFieldConditionFieldPathErrorMessage = invalidSubscriptionFieldConditionFieldPathErrorMessage;
 function invalidSubscriptionFieldConditionFieldPathParentErrorMessage(inputPath, fullConditionFieldPath, partialConditionFieldPath) {
     return (` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
         `\n However, "${partialConditionFieldPath}" is not type "object"`);
 }
-exports.invalidSubscriptionFieldConditionFieldPathParentErrorMessage = invalidSubscriptionFieldConditionFieldPathParentErrorMessage;
 function undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage(inputPath, fullConditionFieldPath, partialConditionFieldPath, fieldName, parentTypeName) {
     return (` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
         `\n However, the path "${partialConditionFieldPath}" is invalid because no field named "${fieldName}"` +
         ` exists on type "${parentTypeName}".`);
 }
-exports.undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage = undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage;
 function invalidSubscriptionFieldConditionFieldPathFieldErrorMessage(inputPath, fullConditionFieldPath, partialConditionFieldPath, fieldPath, subgraphName) {
     return (`Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
         `\n However, only fields that are defined in the same graph as the "@${string_constants_1.SUBSCRIPTION_FILTER}" directive` +
@@ -1015,17 +1016,14 @@ function invalidSubscriptionFieldConditionFieldPathFieldErrorMessage(inputPath,
         `\n Consequently, the path "${partialConditionFieldPath}" is invalid because field "${fieldPath}"` +
         ` is not defined in subgraph "${subgraphName}".`);
 }
-exports.invalidSubscriptionFieldConditionFieldPathFieldErrorMessage = invalidSubscriptionFieldConditionFieldPathFieldErrorMessage;
 function inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage(inputPath, fullConditionFieldPath, partialConditionFieldPath, fieldPath) {
     return (` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
         `\n  The path segment "${partialConditionFieldPath}" is invalid because it refers to "${fieldPath}",` +
         ` which is declared @inaccessible.`);
 }
-exports.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage = inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage;
 function nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage(inputPath, fullConditionFieldPath, fieldName, typeString, namedTypeName) {
     return (` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
         `\n However, the final field "${fieldName}" is ${typeString} "${namedTypeName}", which is not a leaf type;` +
         ` therefore, it requires further selections.`);
 }
-exports.nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage = nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage;
 //# sourceMappingURL=errors.js.map