@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/graphql/validation/rules/custom/NoDeprecatedCustomRule.js

@@ -0,0 +1,173 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.NoDeprecatedCustomRule = NoDeprecatedCustomRule;
+
+var _invariant = require('../../../jsutils/invariant.js');
+
+var _GraphQLError = require('../../../error/GraphQLError.js');
+
+var _definition = require('../../../type/definition.js');
+
+/** @category Custom Rules */
+
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLObjectType,
+ *   GraphQLSchema,
+ *   GraphQLString,
+ *   parse,
+ *   validate,
+ * } from 'graphql';
+ * import { NoDeprecatedCustomRule } from 'graphql/validation';
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       name: { type: GraphQLString },
+ *       oldName: {
+ *         type: GraphQLString,
+ *         deprecationReason: 'Use name instead.',
+ *       },
+ *     },
+ *   }),
+ * });
+ *
+ * const invalidDocument = parse(`
+ *   { oldName }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoDeprecatedCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoDeprecatedCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+function NoDeprecatedCustomRule(context) {
+  return {
+    Field(node) {
+      const fieldDef = context.getFieldDef();
+      const deprecationReason =
+        fieldDef === null || fieldDef === void 0
+          ? void 0
+          : fieldDef.deprecationReason;
+
+      if (fieldDef && deprecationReason != null) {
+        const parentType = context.getParentType();
+        parentType != null || (0, _invariant.invariant)(false);
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+
+    Argument(node) {
+      const argDef = context.getArgument();
+      const deprecationReason =
+        argDef === null || argDef === void 0
+          ? void 0
+          : argDef.deprecationReason;
+
+      if (argDef && deprecationReason != null) {
+        const directiveDef = context.getDirective();
+
+        if (directiveDef != null) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Directive "@${directiveDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        } else {
+          const parentType = context.getParentType();
+          const fieldDef = context.getFieldDef();
+          (parentType != null && fieldDef != null) ||
+            (0, _invariant.invariant)(false);
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const inputObjectDef = (0, _definition.getNamedType)(
+        context.getParentInputType(),
+      );
+
+      if ((0, _definition.isInputObjectType)(inputObjectDef)) {
+        const inputFieldDef = inputObjectDef.getFields()[node.name.value];
+        const deprecationReason =
+          inputFieldDef === null || inputFieldDef === void 0
+            ? void 0
+            : inputFieldDef.deprecationReason;
+
+        if (deprecationReason != null) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        }
+      }
+    },
+
+    EnumValue(node) {
+      const enumValueDef = context.getEnumValue();
+      const deprecationReason =
+        enumValueDef === null || enumValueDef === void 0
+          ? void 0
+          : enumValueDef.deprecationReason;
+
+      if (enumValueDef && deprecationReason != null) {
+        const enumTypeDef = (0, _definition.getNamedType)(
+          context.getInputType(),
+        );
+        enumTypeDef != null || (0, _invariant.invariant)(false);
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/rules/custom/NoDeprecatedCustomRule.mjs

@@ -0,0 +1,158 @@
+/** @category Custom Rules */
+import { invariant } from '../../../jsutils/invariant.mjs';
+import { GraphQLError } from '../../../error/GraphQLError.mjs';
+import { getNamedType, isInputObjectType } from '../../../type/definition.mjs';
+
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLObjectType,
+ *   GraphQLSchema,
+ *   GraphQLString,
+ *   parse,
+ *   validate,
+ * } from 'graphql';
+ * import { NoDeprecatedCustomRule } from 'graphql/validation';
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       name: { type: GraphQLString },
+ *       oldName: {
+ *         type: GraphQLString,
+ *         deprecationReason: 'Use name instead.',
+ *       },
+ *     },
+ *   }),
+ * });
+ *
+ * const invalidDocument = parse(`
+ *   { oldName }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoDeprecatedCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoDeprecatedCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export function NoDeprecatedCustomRule(context) {
+  return {
+    Field(node) {
+      const fieldDef = context.getFieldDef();
+      const deprecationReason =
+        fieldDef === null || fieldDef === void 0
+          ? void 0
+          : fieldDef.deprecationReason;
+
+      if (fieldDef && deprecationReason != null) {
+        const parentType = context.getParentType();
+        parentType != null || invariant(false);
+        context.reportError(
+          new GraphQLError(
+            `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+
+    Argument(node) {
+      const argDef = context.getArgument();
+      const deprecationReason =
+        argDef === null || argDef === void 0
+          ? void 0
+          : argDef.deprecationReason;
+
+      if (argDef && deprecationReason != null) {
+        const directiveDef = context.getDirective();
+
+        if (directiveDef != null) {
+          context.reportError(
+            new GraphQLError(
+              `Directive "@${directiveDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        } else {
+          const parentType = context.getParentType();
+          const fieldDef = context.getFieldDef();
+          (parentType != null && fieldDef != null) || invariant(false);
+          context.reportError(
+            new GraphQLError(
+              `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const inputObjectDef = getNamedType(context.getParentInputType());
+
+      if (isInputObjectType(inputObjectDef)) {
+        const inputFieldDef = inputObjectDef.getFields()[node.name.value];
+        const deprecationReason =
+          inputFieldDef === null || inputFieldDef === void 0
+            ? void 0
+            : inputFieldDef.deprecationReason;
+
+        if (deprecationReason != null) {
+          context.reportError(
+            new GraphQLError(
+              `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,
+              {
+                nodes: node,
+              },
+            ),
+          );
+        }
+      }
+    },
+
+    EnumValue(node) {
+      const enumValueDef = context.getEnumValue();
+      const deprecationReason =
+        enumValueDef === null || enumValueDef === void 0
+          ? void 0
+          : enumValueDef.deprecationReason;
+
+      if (enumValueDef && deprecationReason != null) {
+        const enumTypeDef = getNamedType(context.getInputType());
+        enumTypeDef != null || invariant(false);
+        context.reportError(
+          new GraphQLError(
+            `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/rules/custom/NoSchemaIntrospectionCustomRule.d.ts

@@ -0,0 +1,43 @@
+/** @category Custom Rules */
+import type { ASTVisitor } from '../../../language/visitor';
+import type { ValidationContext } from '../../ValidationContext';
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoSchemaIntrospectionCustomRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function NoSchemaIntrospectionCustomRule(
+  context: ValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/custom/NoSchemaIntrospectionCustomRule.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.NoSchemaIntrospectionCustomRule = NoSchemaIntrospectionCustomRule;
+
+var _GraphQLError = require('../../../error/GraphQLError.js');
+
+var _definition = require('../../../type/definition.js');
+
+var _introspection = require('../../../type/introspection.js');
+
+/** @category Custom Rules */
+
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoSchemaIntrospectionCustomRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+function NoSchemaIntrospectionCustomRule(context) {
+  return {
+    Field(node) {
+      const type = (0, _definition.getNamedType)(context.getType());
+
+      if (type && (0, _introspection.isIntrospectionType)(type)) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `GraphQL introspection has been disabled, but the requested query contained the field "${node.name.value}".`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/rules/custom/NoSchemaIntrospectionCustomRule.mjs

@@ -0,0 +1,60 @@
+/** @category Custom Rules */
+import { GraphQLError } from '../../../error/GraphQLError.mjs';
+import { getNamedType } from '../../../type/definition.mjs';
+import { isIntrospectionType } from '../../../type/introspection.mjs';
+
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoSchemaIntrospectionCustomRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoSchemaIntrospectionCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export function NoSchemaIntrospectionCustomRule(context) {
+  return {
+    Field(node) {
+      const type = getNamedType(context.getType());
+
+      if (type && isIntrospectionType(type)) {
+        context.reportError(
+          new GraphQLError(
+            `GraphQL introspection has been disabled, but the requested query contained the field "${node.name.value}".`,
+            {
+              nodes: node,
+            },
+          ),
+        );
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/specifiedRules.d.ts

@@ -0,0 +1,17 @@
+/** @category Validation Rules */
+import { MaxIntrospectionDepthRule } from './rules/MaxIntrospectionDepthRule';
+import type { SDLValidationRule, ValidationRule } from './ValidationContext';
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+export declare const recommendedRules: readonly typeof MaxIntrospectionDepthRule[];
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+export declare const specifiedRules: ReadonlyArray<ValidationRule>;
+/** @internal */
+export declare const specifiedSDLRules: ReadonlyArray<SDLValidationRule>;

package/node_modules/graphql/validation/specifiedRules.js

@@ -0,0 +1,175 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.specifiedSDLRules =
+  exports.specifiedRules =
+  exports.recommendedRules =
+    void 0;
+
+var _ExecutableDefinitionsRule = require('./rules/ExecutableDefinitionsRule.js');
+
+var _FieldsOnCorrectTypeRule = require('./rules/FieldsOnCorrectTypeRule.js');
+
+var _FragmentsOnCompositeTypesRule = require('./rules/FragmentsOnCompositeTypesRule.js');
+
+var _KnownArgumentNamesRule = require('./rules/KnownArgumentNamesRule.js');
+
+var _KnownDirectivesRule = require('./rules/KnownDirectivesRule.js');
+
+var _KnownFragmentNamesRule = require('./rules/KnownFragmentNamesRule.js');
+
+var _KnownTypeNamesRule = require('./rules/KnownTypeNamesRule.js');
+
+var _LoneAnonymousOperationRule = require('./rules/LoneAnonymousOperationRule.js');
+
+var _LoneSchemaDefinitionRule = require('./rules/LoneSchemaDefinitionRule.js');
+
+var _MaxIntrospectionDepthRule = require('./rules/MaxIntrospectionDepthRule.js');
+
+var _NoFragmentCyclesRule = require('./rules/NoFragmentCyclesRule.js');
+
+var _NoUndefinedVariablesRule = require('./rules/NoUndefinedVariablesRule.js');
+
+var _NoUnusedFragmentsRule = require('./rules/NoUnusedFragmentsRule.js');
+
+var _NoUnusedVariablesRule = require('./rules/NoUnusedVariablesRule.js');
+
+var _OverlappingFieldsCanBeMergedRule = require('./rules/OverlappingFieldsCanBeMergedRule.js');
+
+var _PossibleFragmentSpreadsRule = require('./rules/PossibleFragmentSpreadsRule.js');
+
+var _PossibleTypeExtensionsRule = require('./rules/PossibleTypeExtensionsRule.js');
+
+var _ProvidedRequiredArgumentsRule = require('./rules/ProvidedRequiredArgumentsRule.js');
+
+var _ScalarLeafsRule = require('./rules/ScalarLeafsRule.js');
+
+var _SingleFieldSubscriptionsRule = require('./rules/SingleFieldSubscriptionsRule.js');
+
+var _UniqueArgumentDefinitionNamesRule = require('./rules/UniqueArgumentDefinitionNamesRule.js');
+
+var _UniqueArgumentNamesRule = require('./rules/UniqueArgumentNamesRule.js');
+
+var _UniqueDirectiveNamesRule = require('./rules/UniqueDirectiveNamesRule.js');
+
+var _UniqueDirectivesPerLocationRule = require('./rules/UniqueDirectivesPerLocationRule.js');
+
+var _UniqueEnumValueNamesRule = require('./rules/UniqueEnumValueNamesRule.js');
+
+var _UniqueFieldDefinitionNamesRule = require('./rules/UniqueFieldDefinitionNamesRule.js');
+
+var _UniqueFragmentNamesRule = require('./rules/UniqueFragmentNamesRule.js');
+
+var _UniqueInputFieldNamesRule = require('./rules/UniqueInputFieldNamesRule.js');
+
+var _UniqueOperationNamesRule = require('./rules/UniqueOperationNamesRule.js');
+
+var _UniqueOperationTypesRule = require('./rules/UniqueOperationTypesRule.js');
+
+var _UniqueTypeNamesRule = require('./rules/UniqueTypeNamesRule.js');
+
+var _UniqueVariableNamesRule = require('./rules/UniqueVariableNamesRule.js');
+
+var _ValuesOfCorrectTypeRule = require('./rules/ValuesOfCorrectTypeRule.js');
+
+var _VariablesAreInputTypesRule = require('./rules/VariablesAreInputTypesRule.js');
+
+var _VariablesInAllowedPositionRule = require('./rules/VariablesInAllowedPositionRule.js');
+
+/** @category Validation Rules */
+// Spec Section: "Executable Definitions"
+// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+// Spec Section: "Fragments on Composite Types"
+// Spec Section: "Argument Names"
+// Spec Section: "Directives Are Defined"
+// Spec Section: "Fragment spread target defined"
+// Spec Section: "Fragment Spread Type Existence"
+// Spec Section: "Lone Anonymous Operation"
+// SDL-specific validation rules
+// TODO: Spec Section
+// Spec Section: "Fragments must not form cycles"
+// Spec Section: "All Variable Used Defined"
+// Spec Section: "Fragments must be used"
+// Spec Section: "All Variables Used"
+// Spec Section: "Field Selection Merging"
+// Spec Section: "Fragment spread is possible"
+// Spec Section: "Argument Optionality"
+// Spec Section: "Leaf Field Selections"
+// Spec Section: "Subscriptions with Single Root Field"
+// Spec Section: "Argument Uniqueness"
+// Spec Section: "Directives Are Unique Per Location"
+// Spec Section: "Fragment Name Uniqueness"
+// Spec Section: "Input Object Field Uniqueness"
+// Spec Section: "Operation Name Uniqueness"
+// Spec Section: "Variable Uniqueness"
+// Spec Section: "Value Type Correctness"
+// Spec Section: "Variables are Input Types"
+// Spec Section: "All Variable Usages Are Allowed"
+
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+const recommendedRules = Object.freeze([
+  _MaxIntrospectionDepthRule.MaxIntrospectionDepthRule,
+]);
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+
+exports.recommendedRules = recommendedRules;
+const specifiedRules = Object.freeze([
+  _ExecutableDefinitionsRule.ExecutableDefinitionsRule,
+  _UniqueOperationNamesRule.UniqueOperationNamesRule,
+  _LoneAnonymousOperationRule.LoneAnonymousOperationRule,
+  _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule,
+  _VariablesAreInputTypesRule.VariablesAreInputTypesRule,
+  _ScalarLeafsRule.ScalarLeafsRule,
+  _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule,
+  _UniqueFragmentNamesRule.UniqueFragmentNamesRule,
+  _KnownFragmentNamesRule.KnownFragmentNamesRule,
+  _NoUnusedFragmentsRule.NoUnusedFragmentsRule,
+  _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule,
+  _NoFragmentCyclesRule.NoFragmentCyclesRule,
+  _UniqueVariableNamesRule.UniqueVariableNamesRule,
+  _NoUndefinedVariablesRule.NoUndefinedVariablesRule,
+  _NoUnusedVariablesRule.NoUnusedVariablesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule,
+  _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule,
+  _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+  ...recommendedRules,
+]);
+/** @internal */
+
+exports.specifiedRules = specifiedRules;
+const specifiedSDLRules = Object.freeze([
+  _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule,
+  _UniqueOperationTypesRule.UniqueOperationTypesRule,
+  _UniqueTypeNamesRule.UniqueTypeNamesRule,
+  _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule,
+  _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule,
+  _UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule,
+  _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesOnDirectivesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsOnDirectivesRule,
+]);
+exports.specifiedSDLRules = specifiedSDLRules;