graphql 16.14.0 → 16.14.1

package/validation/rules/NoUnusedFragmentsRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ASTValidationContext } from '../ValidationContext';
  * within operations, or spread within other fragments spread within operations.
  *
  * See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used
+ * @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 { NoUnusedFragmentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Unused on Query { name } query { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedFragmentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Used on Query { name } query { ...Used }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedFragmentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function NoUnusedFragmentsRule(
   context: ASTValidationContext,

package/validation/rules/NoUnusedFragmentsRule.js

@@ -7,6 +7,8 @@ exports.NoUnusedFragmentsRule = NoUnusedFragmentsRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * No unused fragments
  *
@@ -14,6 +16,33 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * within operations, or spread within other fragments spread within operations.
  *
  * See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used
+ * @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 { NoUnusedFragmentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Unused on Query { name } query { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedFragmentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Used on Query { name } query { ...Used }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedFragmentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function NoUnusedFragmentsRule(context) {
   const operationDefs = [];

package/validation/rules/NoUnusedFragmentsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
@@ -7,6 +8,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * within operations, or spread within other fragments spread within operations.
  *
  * See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used
+ * @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 { NoUnusedFragmentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Unused on Query { name } query { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedFragmentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Used on Query { name } query { ...Used }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedFragmentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function NoUnusedFragmentsRule(context) {
   const operationDefs = [];

package/validation/rules/NoUnusedVariablesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,34 @@ import type { ValidationContext } from '../ValidationContext';
  * are used, either directly or within a spread fragment.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variables-Used
+ * @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 { NoUnusedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function NoUnusedVariablesRule(
   context: ValidationContext,

package/validation/rules/NoUnusedVariablesRule.js

@@ -7,6 +7,8 @@ exports.NoUnusedVariablesRule = NoUnusedVariablesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * No unused variables
  *
@@ -14,6 +16,34 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * are used, either directly or within a spread fragment.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variables-Used
+ * @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 { NoUnusedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function NoUnusedVariablesRule(context) {
   let variableDefs = [];

package/validation/rules/NoUnusedVariablesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
@@ -7,6 +8,34 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * are used, either directly or within a spread fragment.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variables-Used
+ * @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 { NoUnusedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUnusedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUnusedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function NoUnusedVariablesRule(context) {
   let variableDefs = [];

package/validation/rules/OverlappingFieldsCanBeMergedRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -8,6 +9,38 @@ import type { ValidationContext } from '../ValidationContext';
  * without ambiguity.
  *
  * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging
+ * @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 { OverlappingFieldsCanBeMergedRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     name: String
+ *     barkVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { value: barkVolume value: name } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { barkVolume name } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function OverlappingFieldsCanBeMergedRule(
   context: ValidationContext,

package/validation/rules/OverlappingFieldsCanBeMergedRule.js

@@ -19,6 +19,7 @@ var _sortValueNode = require('../../utilities/sortValueNode.js');
 
 var _typeFromAST = require('../../utilities/typeFromAST.js');
 
+/** @category Validation Rules */
 function reasonMessage(reason) {
   if (Array.isArray(reason)) {
     return reason
@@ -40,6 +41,38 @@ function reasonMessage(reason) {
  * without ambiguity.
  *
  * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging
+ * @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 { OverlappingFieldsCanBeMergedRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     name: String
+ *     barkVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { value: barkVolume value: name } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { barkVolume name } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 
 function OverlappingFieldsCanBeMergedRule(context) {
@@ -79,6 +112,10 @@ function OverlappingFieldsCanBeMergedRule(context) {
 }
 
 /**
+ * Find all conflicts found "within" a selection set, including those found
+ * via spreading in fragments. Called when visiting each SelectionSet in the
+ * GraphQL Document.
+ *
  * Algorithm:
  *
  * Conflicts occur when two fields exist in a query which will produce the same
@@ -94,7 +131,7 @@ function OverlappingFieldsCanBeMergedRule(context) {
  * A) Each selection set represented in the document first compares "within" its
  * collected set of fields, finding any conflicts between every pair of
  * overlapping fields.
- * Note: This is the *only time* that a the fields "within" a set are compared
+ * Note: This is the *only time* that the fields "within" a set are compared
  * to each other. After this only fields "between" sets are compared.
  *
  * B) Also, if any fragment is referenced in a selection set, then a
@@ -106,14 +143,14 @@ function OverlappingFieldsCanBeMergedRule(context) {
  *
  * D) When comparing "between" a set of fields and a referenced fragment, first
  * a comparison is made between each field in the original set of fields and
- * each field in the the referenced set of fields.
+ * each field in the referenced set of fields.
  *
  * E) Also, if any fragment is referenced in the referenced selection set,
  * then a comparison is made "between" the original set of fields and the
  * referenced fragment (recursively referring to step D).
  *
  * F) When comparing "between" two fragments, first a comparison is made between
- * each field in the first referenced set of fields and each field in the the
+ * each field in the first referenced set of fields and each field in the
  * second referenced set of fields.
  *
  * G) Also, any fragments referenced by the first must be compared to the
@@ -131,10 +168,8 @@ function OverlappingFieldsCanBeMergedRule(context) {
  * J) Also, if two fragments are referenced in both selection sets, then a
  * comparison is made "between" the two fragments.
  *
+ * @internal
  */
-// Find all conflicts found "within" a selection set, including those found
-// via spreading in fragments. Called when visiting each SelectionSet in the
-// GraphQL Document.
 function findConflictsWithinSelectionSet(
   context,
   cachedFieldsAndFragmentNames,
@@ -809,6 +844,8 @@ function subfieldConflicts(conflicts, responseName, node1, node2) {
  *
  * Provides a third argument for has/set to allow flagging the pair as
  * weakly or strongly present within the collection.
+ *
+ * @internal
  */
 
 class OrderedPairSet {
@@ -845,6 +882,8 @@ class OrderedPairSet {
 /**
  * A way to keep track of pairs of similar things when the ordering of the pair
  * does not matter.
+ *
+ * @internal
  */
 
 class PairSet {

package/validation/rules/OverlappingFieldsCanBeMergedRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { inspect } from '../../jsutils/inspect.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { Kind } from '../../language/kinds.mjs';
@@ -34,6 +35,38 @@ function reasonMessage(reason) {
  * without ambiguity.
  *
  * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging
+ * @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 { OverlappingFieldsCanBeMergedRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     name: String
+ *     barkVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { value: barkVolume value: name } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { barkVolume name } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [OverlappingFieldsCanBeMergedRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 
 export function OverlappingFieldsCanBeMergedRule(context) {
@@ -73,6 +106,10 @@ export function OverlappingFieldsCanBeMergedRule(context) {
 }
 
 /**
+ * Find all conflicts found "within" a selection set, including those found
+ * via spreading in fragments. Called when visiting each SelectionSet in the
+ * GraphQL Document.
+ *
  * Algorithm:
  *
  * Conflicts occur when two fields exist in a query which will produce the same
@@ -88,7 +125,7 @@ export function OverlappingFieldsCanBeMergedRule(context) {
  * A) Each selection set represented in the document first compares "within" its
  * collected set of fields, finding any conflicts between every pair of
  * overlapping fields.
- * Note: This is the *only time* that a the fields "within" a set are compared
+ * Note: This is the *only time* that the fields "within" a set are compared
  * to each other. After this only fields "between" sets are compared.
  *
  * B) Also, if any fragment is referenced in a selection set, then a
@@ -100,14 +137,14 @@ export function OverlappingFieldsCanBeMergedRule(context) {
  *
  * D) When comparing "between" a set of fields and a referenced fragment, first
  * a comparison is made between each field in the original set of fields and
- * each field in the the referenced set of fields.
+ * each field in the referenced set of fields.
  *
  * E) Also, if any fragment is referenced in the referenced selection set,
  * then a comparison is made "between" the original set of fields and the
  * referenced fragment (recursively referring to step D).
  *
  * F) When comparing "between" two fragments, first a comparison is made between
- * each field in the first referenced set of fields and each field in the the
+ * each field in the first referenced set of fields and each field in the
  * second referenced set of fields.
  *
  * G) Also, any fragments referenced by the first must be compared to the
@@ -125,10 +162,8 @@ export function OverlappingFieldsCanBeMergedRule(context) {
  * J) Also, if two fragments are referenced in both selection sets, then a
  * comparison is made "between" the two fragments.
  *
+ * @internal
  */
-// Find all conflicts found "within" a selection set, including those found
-// via spreading in fragments. Called when visiting each SelectionSet in the
-// GraphQL Document.
 function findConflictsWithinSelectionSet(
   context,
   cachedFieldsAndFragmentNames,
@@ -794,6 +829,8 @@ function subfieldConflicts(conflicts, responseName, node1, node2) {
  *
  * Provides a third argument for has/set to allow flagging the pair as
  * weakly or strongly present within the collection.
+ *
+ * @internal
  */
 
 class OrderedPairSet {
@@ -830,6 +867,8 @@ class OrderedPairSet {
 /**
  * A way to keep track of pairs of similar things when the ordering of the pair
  * does not matter.
+ *
+ * @internal
  */
 
 class PairSet {

package/validation/rules/PossibleFragmentSpreadsRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -6,6 +7,41 @@ import type { ValidationContext } from '../ValidationContext';
  * A fragment spread is only valid if the type condition could ever possibly
  * be true: if there is a non-empty intersection of the possible parent types,
  * and possible types which pass the type condition.
+ * @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 { PossibleFragmentSpreadsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     barkVolume: Int
+ *   }
+ *
+ *   type Cat {
+ *     meowVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { ... on Cat { meowVolume } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { ... on Dog { barkVolume } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function PossibleFragmentSpreadsRule(
   context: ValidationContext,

package/validation/rules/PossibleFragmentSpreadsRule.js

@@ -15,12 +15,49 @@ var _typeComparators = require('../../utilities/typeComparators.js');
 
 var _typeFromAST = require('../../utilities/typeFromAST.js');
 
+/** @category Validation Rules */
+
 /**
  * Possible fragment spread
  *
  * A fragment spread is only valid if the type condition could ever possibly
  * be true: if there is a non-empty intersection of the possible parent types,
  * and possible types which pass the type condition.
+ * @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 { PossibleFragmentSpreadsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     barkVolume: Int
+ *   }
+ *
+ *   type Cat {
+ *     meowVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { ... on Cat { meowVolume } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { ... on Dog { barkVolume } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function PossibleFragmentSpreadsRule(context) {
   return {

package/validation/rules/PossibleFragmentSpreadsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { inspect } from '../../jsutils/inspect.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { isCompositeType } from '../../type/definition.mjs';
@@ -10,6 +11,41 @@ import { typeFromAST } from '../../utilities/typeFromAST.mjs';
  * A fragment spread is only valid if the type condition could ever possibly
  * be true: if there is a non-empty intersection of the possible parent types,
  * and possible types which pass the type condition.
+ * @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 { PossibleFragmentSpreadsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     dog: Dog
+ *   }
+ *
+ *   type Dog {
+ *     barkVolume: Int
+ *   }
+ *
+ *   type Cat {
+ *     meowVolume: Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { dog { ... on Cat { meowVolume } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { dog { ... on Dog { barkVolume } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [PossibleFragmentSpreadsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function PossibleFragmentSpreadsRule(context) {
   return {

package/validation/rules/PossibleTypeExtensionsRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { SDLValidationContext } from '../ValidationContext';
 /**
  * Possible type extension
  *
  * A type extension is only valid if the type is defined and has the same kind.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { PossibleTypeExtensionsRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   extend type Missing { name: String } type Query { name: String }
+ * `;
+ *
+ * PossibleTypeExtensionsRule.name; // => 'PossibleTypeExtensionsRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } extend type Query { other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function PossibleTypeExtensionsRule(
   context: SDLValidationContext,