@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/graphql/validation/index.js

@@ -0,0 +1,331 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'ExecutableDefinitionsRule', {
+  enumerable: true,
+  get: function () {
+    return _ExecutableDefinitionsRule.ExecutableDefinitionsRule;
+  },
+});
+Object.defineProperty(exports, 'FieldsOnCorrectTypeRule', {
+  enumerable: true,
+  get: function () {
+    return _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule;
+  },
+});
+Object.defineProperty(exports, 'FragmentsOnCompositeTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownArgumentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownArgumentNamesRule.KnownArgumentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownDirectivesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownDirectivesRule.KnownDirectivesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownFragmentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownFragmentNamesRule.KnownFragmentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'KnownTypeNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _KnownTypeNamesRule.KnownTypeNamesRule;
+  },
+});
+Object.defineProperty(exports, 'LoneAnonymousOperationRule', {
+  enumerable: true,
+  get: function () {
+    return _LoneAnonymousOperationRule.LoneAnonymousOperationRule;
+  },
+});
+Object.defineProperty(exports, 'LoneSchemaDefinitionRule', {
+  enumerable: true,
+  get: function () {
+    return _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule;
+  },
+});
+Object.defineProperty(exports, 'MaxIntrospectionDepthRule', {
+  enumerable: true,
+  get: function () {
+    return _MaxIntrospectionDepthRule.MaxIntrospectionDepthRule;
+  },
+});
+Object.defineProperty(exports, 'NoDeprecatedCustomRule', {
+  enumerable: true,
+  get: function () {
+    return _NoDeprecatedCustomRule.NoDeprecatedCustomRule;
+  },
+});
+Object.defineProperty(exports, 'NoFragmentCyclesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoFragmentCyclesRule.NoFragmentCyclesRule;
+  },
+});
+Object.defineProperty(exports, 'NoSchemaIntrospectionCustomRule', {
+  enumerable: true,
+  get: function () {
+    return _NoSchemaIntrospectionCustomRule.NoSchemaIntrospectionCustomRule;
+  },
+});
+Object.defineProperty(exports, 'NoUndefinedVariablesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUndefinedVariablesRule.NoUndefinedVariablesRule;
+  },
+});
+Object.defineProperty(exports, 'NoUnusedFragmentsRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUnusedFragmentsRule.NoUnusedFragmentsRule;
+  },
+});
+Object.defineProperty(exports, 'NoUnusedVariablesRule', {
+  enumerable: true,
+  get: function () {
+    return _NoUnusedVariablesRule.NoUnusedVariablesRule;
+  },
+});
+Object.defineProperty(exports, 'OverlappingFieldsCanBeMergedRule', {
+  enumerable: true,
+  get: function () {
+    return _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule;
+  },
+});
+Object.defineProperty(exports, 'PossibleFragmentSpreadsRule', {
+  enumerable: true,
+  get: function () {
+    return _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule;
+  },
+});
+Object.defineProperty(exports, 'PossibleTypeExtensionsRule', {
+  enumerable: true,
+  get: function () {
+    return _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule;
+  },
+});
+Object.defineProperty(exports, 'ProvidedRequiredArgumentsRule', {
+  enumerable: true,
+  get: function () {
+    return _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule;
+  },
+});
+Object.defineProperty(exports, 'ScalarLeafsRule', {
+  enumerable: true,
+  get: function () {
+    return _ScalarLeafsRule.ScalarLeafsRule;
+  },
+});
+Object.defineProperty(exports, 'SingleFieldSubscriptionsRule', {
+  enumerable: true,
+  get: function () {
+    return _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueArgumentDefinitionNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueArgumentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueArgumentNamesRule.UniqueArgumentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueDirectiveNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueDirectivesPerLocationRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueEnumValueNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueFieldDefinitionNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueFragmentNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueFragmentNamesRule.UniqueFragmentNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueInputFieldNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueOperationNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueOperationNamesRule.UniqueOperationNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueOperationTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueOperationTypesRule.UniqueOperationTypesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueTypeNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueTypeNamesRule.UniqueTypeNamesRule;
+  },
+});
+Object.defineProperty(exports, 'UniqueVariableNamesRule', {
+  enumerable: true,
+  get: function () {
+    return _UniqueVariableNamesRule.UniqueVariableNamesRule;
+  },
+});
+Object.defineProperty(exports, 'ValidationContext', {
+  enumerable: true,
+  get: function () {
+    return _ValidationContext.ValidationContext;
+  },
+});
+Object.defineProperty(exports, 'ValuesOfCorrectTypeRule', {
+  enumerable: true,
+  get: function () {
+    return _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule;
+  },
+});
+Object.defineProperty(exports, 'VariablesAreInputTypesRule', {
+  enumerable: true,
+  get: function () {
+    return _VariablesAreInputTypesRule.VariablesAreInputTypesRule;
+  },
+});
+Object.defineProperty(exports, 'VariablesInAllowedPositionRule', {
+  enumerable: true,
+  get: function () {
+    return _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule;
+  },
+});
+Object.defineProperty(exports, 'recommendedRules', {
+  enumerable: true,
+  get: function () {
+    return _specifiedRules.recommendedRules;
+  },
+});
+Object.defineProperty(exports, 'specifiedRules', {
+  enumerable: true,
+  get: function () {
+    return _specifiedRules.specifiedRules;
+  },
+});
+Object.defineProperty(exports, 'validate', {
+  enumerable: true,
+  get: function () {
+    return _validate.validate;
+  },
+});
+
+var _validate = require('./validate.js');
+
+var _ValidationContext = require('./ValidationContext.js');
+
+var _specifiedRules = require('./specifiedRules.js');
+
+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 _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 _ProvidedRequiredArgumentsRule = require('./rules/ProvidedRequiredArgumentsRule.js');
+
+var _ScalarLeafsRule = require('./rules/ScalarLeafsRule.js');
+
+var _SingleFieldSubscriptionsRule = require('./rules/SingleFieldSubscriptionsRule.js');
+
+var _UniqueArgumentNamesRule = require('./rules/UniqueArgumentNamesRule.js');
+
+var _UniqueDirectivesPerLocationRule = require('./rules/UniqueDirectivesPerLocationRule.js');
+
+var _UniqueFragmentNamesRule = require('./rules/UniqueFragmentNamesRule.js');
+
+var _UniqueInputFieldNamesRule = require('./rules/UniqueInputFieldNamesRule.js');
+
+var _UniqueOperationNamesRule = require('./rules/UniqueOperationNamesRule.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');
+
+var _MaxIntrospectionDepthRule = require('./rules/MaxIntrospectionDepthRule.js');
+
+var _LoneSchemaDefinitionRule = require('./rules/LoneSchemaDefinitionRule.js');
+
+var _UniqueOperationTypesRule = require('./rules/UniqueOperationTypesRule.js');
+
+var _UniqueTypeNamesRule = require('./rules/UniqueTypeNamesRule.js');
+
+var _UniqueEnumValueNamesRule = require('./rules/UniqueEnumValueNamesRule.js');
+
+var _UniqueFieldDefinitionNamesRule = require('./rules/UniqueFieldDefinitionNamesRule.js');
+
+var _UniqueArgumentDefinitionNamesRule = require('./rules/UniqueArgumentDefinitionNamesRule.js');
+
+var _UniqueDirectiveNamesRule = require('./rules/UniqueDirectiveNamesRule.js');
+
+var _PossibleTypeExtensionsRule = require('./rules/PossibleTypeExtensionsRule.js');
+
+var _NoDeprecatedCustomRule = require('./rules/custom/NoDeprecatedCustomRule.js');
+
+var _NoSchemaIntrospectionCustomRule = require('./rules/custom/NoSchemaIntrospectionCustomRule.js');

package/node_modules/graphql/validation/index.mjs

@@ -0,0 +1,75 @@
+/**
+ * Validate GraphQL documents and schemas with the specified validation rules.
+ *
+ * These exports are also available from the root `graphql` package.
+ * @packageDocumentation
+ */
+export { validate } from './validate.mjs';
+export { ValidationContext } from './ValidationContext.mjs';
+// All validation rules in the GraphQL Specification.
+export { specifiedRules, recommendedRules } from './specifiedRules.mjs'; // Spec Section: "Executable Definitions"
+
+export { ExecutableDefinitionsRule } from './rules/ExecutableDefinitionsRule.mjs'; // Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+
+export { FieldsOnCorrectTypeRule } from './rules/FieldsOnCorrectTypeRule.mjs'; // Spec Section: "Fragments on Composite Types"
+
+export { FragmentsOnCompositeTypesRule } from './rules/FragmentsOnCompositeTypesRule.mjs'; // Spec Section: "Argument Names"
+
+export { KnownArgumentNamesRule } from './rules/KnownArgumentNamesRule.mjs'; // Spec Section: "Directives Are Defined"
+
+export { KnownDirectivesRule } from './rules/KnownDirectivesRule.mjs'; // Spec Section: "Fragment spread target defined"
+
+export { KnownFragmentNamesRule } from './rules/KnownFragmentNamesRule.mjs'; // Spec Section: "Fragment Spread Type Existence"
+
+export { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.mjs'; // Spec Section: "Lone Anonymous Operation"
+
+export { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.mjs'; // Spec Section: "Fragments must not form cycles"
+
+export { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.mjs'; // Spec Section: "All Variable Used Defined"
+
+export { NoUndefinedVariablesRule } from './rules/NoUndefinedVariablesRule.mjs'; // Spec Section: "Fragments must be used"
+
+export { NoUnusedFragmentsRule } from './rules/NoUnusedFragmentsRule.mjs'; // Spec Section: "All Variables Used"
+
+export { NoUnusedVariablesRule } from './rules/NoUnusedVariablesRule.mjs'; // Spec Section: "Field Selection Merging"
+
+export { OverlappingFieldsCanBeMergedRule } from './rules/OverlappingFieldsCanBeMergedRule.mjs'; // Spec Section: "Fragment spread is possible"
+
+export { PossibleFragmentSpreadsRule } from './rules/PossibleFragmentSpreadsRule.mjs'; // Spec Section: "Argument Optionality"
+
+export { ProvidedRequiredArgumentsRule } from './rules/ProvidedRequiredArgumentsRule.mjs'; // Spec Section: "Leaf Field Selections"
+
+export { ScalarLeafsRule } from './rules/ScalarLeafsRule.mjs'; // Spec Section: "Subscriptions with Single Root Field"
+
+export { SingleFieldSubscriptionsRule } from './rules/SingleFieldSubscriptionsRule.mjs'; // Spec Section: "Argument Uniqueness"
+
+export { UniqueArgumentNamesRule } from './rules/UniqueArgumentNamesRule.mjs'; // Spec Section: "Directives Are Unique Per Location"
+
+export { UniqueDirectivesPerLocationRule } from './rules/UniqueDirectivesPerLocationRule.mjs'; // Spec Section: "Fragment Name Uniqueness"
+
+export { UniqueFragmentNamesRule } from './rules/UniqueFragmentNamesRule.mjs'; // Spec Section: "Input Object Field Uniqueness"
+
+export { UniqueInputFieldNamesRule } from './rules/UniqueInputFieldNamesRule.mjs'; // Spec Section: "Operation Name Uniqueness"
+
+export { UniqueOperationNamesRule } from './rules/UniqueOperationNamesRule.mjs'; // Spec Section: "Variable Uniqueness"
+
+export { UniqueVariableNamesRule } from './rules/UniqueVariableNamesRule.mjs'; // Spec Section: "Values Type Correctness"
+
+export { ValuesOfCorrectTypeRule } from './rules/ValuesOfCorrectTypeRule.mjs'; // Spec Section: "Variables are Input Types"
+
+export { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.mjs'; // Spec Section: "All Variable Usages Are Allowed"
+
+export { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.mjs';
+export { MaxIntrospectionDepthRule } from './rules/MaxIntrospectionDepthRule.mjs'; // SDL-specific validation rules
+
+export { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.mjs';
+export { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.mjs';
+export { UniqueTypeNamesRule } from './rules/UniqueTypeNamesRule.mjs';
+export { UniqueEnumValueNamesRule } from './rules/UniqueEnumValueNamesRule.mjs';
+export { UniqueFieldDefinitionNamesRule } from './rules/UniqueFieldDefinitionNamesRule.mjs';
+export { UniqueArgumentDefinitionNamesRule } from './rules/UniqueArgumentDefinitionNamesRule.mjs';
+export { UniqueDirectiveNamesRule } from './rules/UniqueDirectiveNamesRule.mjs';
+export { PossibleTypeExtensionsRule } from './rules/PossibleTypeExtensionsRule.mjs'; // Optional rules not defined by the GraphQL Specification
+
+export { NoDeprecatedCustomRule } from './rules/custom/NoDeprecatedCustomRule.mjs';
+export { NoSchemaIntrospectionCustomRule } from './rules/custom/NoSchemaIntrospectionCustomRule.mjs';

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.d.ts

@@ -0,0 +1,41 @@
+/** @category Validation Rules */
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ * @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 { ExecutableDefinitionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   type Extra { field: String }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ExecutableDefinitionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ExecutableDefinitionsRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function ExecutableDefinitionsRule(
+  context: ASTValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ExecutableDefinitionsRule = ExecutableDefinitionsRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+var _predicates = require('../../language/predicates.js');
+
+/** @category Validation Rules */
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ * @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 { ExecutableDefinitionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   type Extra { field: String }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ExecutableDefinitionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ExecutableDefinitionsRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+function ExecutableDefinitionsRule(context) {
+  return {
+    Document(node) {
+      for (const definition of node.definitions) {
+        if (!(0, _predicates.isExecutableDefinitionNode)(definition)) {
+          const defName =
+            definition.kind === _kinds.Kind.SCHEMA_DEFINITION ||
+            definition.kind === _kinds.Kind.SCHEMA_EXTENSION
+              ? 'schema'
+              : '"' + definition.name.value + '"';
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `The ${defName} definition is not executable.`,
+              {
+                nodes: definition,
+              },
+            ),
+          );
+        }
+      }
+
+      return false;
+    },
+  };
+}

package/node_modules/graphql/validation/rules/ExecutableDefinitionsRule.mjs

@@ -0,0 +1,62 @@
+/** @category Validation Rules */
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import { isExecutableDefinitionNode } from '../../language/predicates.mjs';
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ * @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 { ExecutableDefinitionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   type Extra { field: String }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ExecutableDefinitionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ExecutableDefinitionsRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export function ExecutableDefinitionsRule(context) {
+  return {
+    Document(node) {
+      for (const definition of node.definitions) {
+        if (!isExecutableDefinitionNode(definition)) {
+          const defName =
+            definition.kind === Kind.SCHEMA_DEFINITION ||
+            definition.kind === Kind.SCHEMA_EXTENSION
+              ? 'schema'
+              : '"' + definition.name.value + '"';
+          context.reportError(
+            new GraphQLError(`The ${defName} definition is not executable.`, {
+              nodes: definition,
+            }),
+          );
+        }
+      }
+
+      return false;
+    },
+  };
+}

package/node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.d.ts

@@ -0,0 +1,41 @@
+/** @category Validation Rules */
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * Fields on correct type
+ *
+ * A GraphQL document is only valid if all fields selected are defined by the
+ * parent type, or are an allowed meta field such as __typename.
+ *
+ * See https://spec.graphql.org/draft/#sec-Field-Selections
+ * @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 { FieldsOnCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { missing }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [FieldsOnCorrectTypeRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [FieldsOnCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function FieldsOnCorrectTypeRule(
+  context: ValidationContext,
+): ASTVisitor;