> 1 | import { ConstArgumentNode, ASTNode, DirectiveLocation, ConstDirectiveNode, DocumentNode, GraphQLError, GraphQLSchema, Kind, TypeNode, VariableDefinitionNode, VariableNode, DirectiveDefinitionNode, DirectiveNode } from "graphql";
    |          ^
  2 | import { CoreImport, CoreSpecDefinition, FeatureUrl, FeatureVersion } from "./specs/coreSpec";
  3 | import { MapWithCachedArrays } from "./utils";
  4 | import { SDLValidationRule } from "graphql/validation/ValidationContext";

> 1 | import { ConstArgumentNode, ASTNode, DirectiveLocation, ConstDirectiveNode, DocumentNode, GraphQLError, GraphQLSchema, Kind, TypeNode, VariableDefinitionNode, VariableNode, DirectiveDefinitionNode, DirectiveNode } from "graphql";
    |                                                         ^
  2 | import { CoreImport, CoreSpecDefinition, FeatureUrl, FeatureVersion } from "./specs/coreSpec";
  3 | import { MapWithCachedArrays } from "./utils";
  4 | import { SDLValidationRule } from "graphql/validation/ValidationContext";

  54 | export declare function supertypes(type: CompositeType): readonly CompositeType[];
  55 | export declare function isConditionalDirective(directive: Directive<any, any> | DirectiveDefinition<any>): boolean;
> 56 | export declare const executableDirectiveLocations: DirectiveLocation[];
     |                                                    ^
  57 | export declare function isExecutableDirectiveLocation(loc: DirectiveLocation): boolean;
  58 | export declare const typeSystemDirectiveLocations: DirectiveLocation[];
  59 | export declare function isTypeSystemDirectiveLocation(loc: DirectiveLocation): boolean;

  55 | export declare function isConditionalDirective(directive: Directive<any, any> | DirectiveDefinition<any>): boolean;
  56 | export declare const executableDirectiveLocations: DirectiveLocation[];
> 57 | export declare function isExecutableDirectiveLocation(loc: DirectiveLocation): boolean;
     |                                                            ^
  58 | export declare const typeSystemDirectiveLocations: DirectiveLocation[];
  59 | export declare function isTypeSystemDirectiveLocation(loc: DirectiveLocation): boolean;
  60 | export declare function typeToAST(type: Type): TypeNode;

  56 | export declare const executableDirectiveLocations: DirectiveLocation[];
  57 | export declare function isExecutableDirectiveLocation(loc: DirectiveLocation): boolean;
> 58 | export declare const typeSystemDirectiveLocations: DirectiveLocation[];
     |                                                    ^
  59 | export declare function isTypeSystemDirectiveLocation(loc: DirectiveLocation): boolean;
  60 | export declare function typeToAST(type: Type): TypeNode;
  61 | export declare function typeFromAST(schema: Schema, node: TypeNode): Type;

  57 | export declare function isExecutableDirectiveLocation(loc: DirectiveLocation): boolean;
  58 | export declare const typeSystemDirectiveLocations: DirectiveLocation[];
> 59 | export declare function isTypeSystemDirectiveLocation(loc: DirectiveLocation): boolean;
     |                                                            ^
  60 | export declare function typeToAST(type: Type): TypeNode;
  61 | export declare function typeFromAST(schema: Schema, node: TypeNode): Type;
  62 | export type LeafType = ScalarType | EnumType;

  359 | export declare class ScalarType extends BaseNamedType<OutputTypeReferencer | InputTypeReferencer, ScalarType> {
  360 |     readonly kind: "ScalarType";
> 361 |     readonly astDefinitionKind = Kind.SCALAR_TYPE_DEFINITION;
      |                                  ^
  362 |     protected removeTypeReference(type: NamedType): void;
  363 |     protected hasNonExtensionInnerElements(): boolean;
  364 |     protected removeInnerElementsExtensions(): void;

  399 | export declare class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer> {
  400 |     readonly kind: "ObjectType";
> 401 |     readonly astDefinitionKind = Kind.OBJECT_TYPE_DEFINITION;
      |                                  ^
  402 |     isRootType(): boolean;
  403 |     isQueryRootType(): boolean;
  404 |     isSubscriptionRootType(): boolean;

  408 | export declare class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeReferencer> {
  409 |     readonly kind: "InterfaceType";
> 410 |     readonly astDefinitionKind = Kind.INTERFACE_TYPE_DEFINITION;
      |                                  ^
  411 |     allImplementations(): (ObjectType | InterfaceType)[];
  412 |     possibleRuntimeTypes(): readonly ObjectType[];
  413 |     isPossibleRuntimeType(type: string | NamedType): boolean;

  421 | export declare class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
  422 |     readonly kind: "UnionType";
> 423 |     readonly astDefinitionKind = Kind.UNION_TYPE_DEFINITION;
      |                                  ^
  424 |     protected readonly _members: MapWithCachedArrays<string, UnionMember>;
  425 |     private _typenameField?;
  426 |     protected onAttached(): void;

  442 | export declare class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
  443 |     readonly kind: "EnumType";
> 444 |     readonly astDefinitionKind = Kind.ENUM_TYPE_DEFINITION;
      |                                  ^
  445 |     private _values;
  446 |     get values(): readonly EnumValue[];
  447 |     value(name: string): EnumValue | undefined;

  457 | export declare class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObjectType> {
  458 |     readonly kind: "InputObjectType";
> 459 |     readonly astDefinitionKind = Kind.INPUT_OBJECT_TYPE_DEFINITION;
      |                                  ^
  460 |     private readonly _fields;
  461 |     private _cachedFieldsArray?;
  462 |     fields(): InputFieldDefinition[];

  570 |     addArgument(name: string, type?: InputType, defaultValue?: any): ArgumentDefinition<DirectiveDefinition>;
  571 |     private removeArgumentInternal;
> 572 |     get locations(): readonly DirectiveLocation[];
      |                               ^
  573 |     addLocations(...locations: DirectiveLocation[]): DirectiveDefinition;
  574 |     addAllLocations(): DirectiveDefinition;
  575 |     addAllTypeLocations(): DirectiveDefinition;

  571 |     private removeArgumentInternal;
  572 |     get locations(): readonly DirectiveLocation[];
> 573 |     addLocations(...locations: DirectiveLocation[]): DirectiveDefinition;
      |                                ^
  574 |     addAllLocations(): DirectiveDefinition;
  575 |     addAllTypeLocations(): DirectiveDefinition;
  576 |     removeLocations(...locations: DirectiveLocation[]): DirectiveDefinition;

  574 |     addAllLocations(): DirectiveDefinition;
  575 |     addAllTypeLocations(): DirectiveDefinition;
> 576 |     removeLocations(...locations: DirectiveLocation[]): DirectiveDefinition;
      |                                   ^
  577 |     hasExecutableLocations(): boolean;
  578 |     hasTypeSystemLocations(): boolean;
  579 |     applications(): ReadonlySet<Directive<SchemaElement<any, any>, TApplicationArgs>>;

  661 |     schema: Schema;
  662 |     copyDirectiveApplicationsInArguments: boolean;
> 663 |     locationFilter?: (loc: DirectiveLocation) => boolean;
      |                            ^
  664 | }): void;
  665 | export declare function isFieldDefinition(elem: SchemaElement<any, any>): elem is FieldDefinition<any>;
  666 | export {};

  47 | export declare function createDirectiveSpecification({ name, locations, repeatable, args, composes, supergraphSpecification, staticArgumentTransform, }: {
  48 |     name: string;
> 49 |     locations: DirectiveLocation[];
     |                ^
  50 |     repeatable?: boolean;
  51 |     args?: DirectiveArgumentSpecification[];
  52 |     composes?: boolean;

> 1 | import { ASTNode, GraphQLError, GraphQLErrorOptions, GraphQLFormattedError } from "graphql";
    |                                 ^
  2 | type SchemaRootKind = 'query' | 'mutation' | 'subscription';
  3 | export type ErrorCodeMetadata = {
  4 |     addedIn: string;

   5 | export declare const inaccessibleIdentity = "https://specs.apollo.dev/inaccessible";
   6 | export declare class InaccessibleSpecDefinition extends FeatureDefinition {
>  7 |     readonly inaccessibleLocations: DirectiveLocation[];
     |                                     ^
   8 |     readonly inaccessibleDirectiveSpec: DirectiveSpecification;
   9 |     private readonly printedInaccessibleDefinition;
  10 |     constructor(version: FeatureVersion, minimumFederationVersion?: FeatureVersion);

   5 | export declare const tagIdentity = "https://specs.apollo.dev/tag";
   6 | export declare class TagSpecDefinition extends FeatureDefinition {
>  7 |     readonly tagLocations: DirectiveLocation[];
     |                            ^
   8 |     readonly tagDirectiveSpec: DirectiveSpecification;
   9 |     private readonly printedTagDefinition;
  10 |     constructor(version: FeatureVersion, minimumFederationVersion?: FeatureVersion);

  1 | import { ArgumentDefinition, EnumType, InputFieldDefinition, InputType, ScalarType, Schema, VariableCollector, VariableDefinitions } from './definitions';
> 2 | import { ArgumentNode, ValueNode, ConstValueNode } from 'graphql';
    |                                   ^
  3 | export declare function valueToString(v: any, expectedType?: InputType): string;
  4 | export declare function valueEquals(a: any, b: any): boolean;
  5 | export declare function argumentsEquals(args1: {

  1 | /// <reference types="zen-observable" />
> 2 | import { ApolloLink, FetchResult, NextLink, Observable, Operation } from '@apollo/client';
    |          ^
  3 | import Dispatcher from './Dispatcher';
  4 | export default class ApolloLinkNetworkStatus extends ApolloLink {
  5 |     dispatcher: Dispatcher;

  1 | /// <reference types="zen-observable" />
> 2 | import { ApolloLink, FetchResult, NextLink, Observable, Operation } from '@apollo/client';
    |                      ^
  3 | import Dispatcher from './Dispatcher';
  4 | export default class ApolloLinkNetworkStatus extends ApolloLink {
  5 |     dispatcher: Dispatcher;

  1 | /// <reference types="zen-observable" />
> 2 | import { ApolloLink, FetchResult, NextLink, Observable, Operation } from '@apollo/client';
    |                                   ^
  3 | import Dispatcher from './Dispatcher';
  4 | export default class ApolloLinkNetworkStatus extends ApolloLink {
  5 |     dispatcher: Dispatcher;

  1 | /// <reference types="zen-observable" />
> 2 | import { ApolloLink, FetchResult, NextLink, Observable, Operation } from '@apollo/client';
    |                                             ^
  3 | import Dispatcher from './Dispatcher';
  4 | export default class ApolloLinkNetworkStatus extends ApolloLink {
  5 |     dispatcher: Dispatcher;