@theguild/federation-composition 0.9.0 → 0.10.0

package/typings/supergraph/state.d.ts

@@ -1,7 +1,6 @@
 import { DirectiveDefinitionNode, TypeDefinitionNode } from 'graphql';
 import { Link } from '../specifications/link.js';
 import { SubgraphState } from '../subgraph/state.js';
-import { Graph } from './composition/common.js';
 import { DirectiveState } from './composition/directive.js';
 import { EnumTypeState } from './composition/enum-type.js';
 import { InputObjectTypeState } from './composition/input-object-type.js';
@@ -10,7 +9,7 @@ import { ObjectTypeState } from './composition/object-type.js';
 import { ScalarTypeState } from './composition/scalar-type.js';
 import { UnionTypeState } from './composition/union-type.js';
 export type SupergraphState = {
-    graphs: Map<string, Graph>;
+    subgraphs: Map<string, SubgraphState>;
     scalarTypes: Map<string, ScalarTypeState>;
     objectTypes: Map<string, ObjectTypeState>;
     interfaceTypes: Map<string, InterfaceTypeState>;
@@ -31,10 +30,11 @@ export type SupergraphState = {
 };
 export type SupergraphStateBuilder = ReturnType<typeof createSupergraphStateBuilder>;
 export declare function createSupergraphStateBuilder(): {
-    addGraph(graph: Graph): void;
-    getGraph(id: string): Graph | undefined;
+    addSubgraph(subgraph: SubgraphState): void;
+    getGraph(id: string): SubgraphState | undefined;
     visitSubgraphState(subgraphState: SubgraphState): void;
     getSupergraphState(): SupergraphState;
+    getSubgraphState(graphId: string): SubgraphState | undefined;
     links(): readonly {
         name: string | null;
         version: string | null;

package/typings/supergraph/validation/rules/satisfiablity/constants.d.cts

@@ -0,0 +1,2 @@
+export declare const SUPERGRAPH_ID: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SUPERGRAPH_ID: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/edge.d.cts

@@ -0,0 +1,31 @@
+import { SatisfiabilityError } from './errors';
+import { AbstractMove, EntityMove, FieldMove, Move } from './moves';
+import { Node } from './node';
+type EdgeResolvabilityResult = {
+    success: true;
+    error: undefined;
+} | {
+    success: false;
+    error: SatisfiabilityError;
+};
+export declare function isEntityEdge(edge: Edge): edge is Edge<EntityMove>;
+export declare function assertEntityEdge(edge: Edge): asserts edge is Edge<EntityMove>;
+export declare function isAbstractEdge(edge: Edge): edge is Edge<AbstractMove>;
+export declare function assertAbstractEdge(edge: Edge): asserts edge is Edge<AbstractMove>;
+export declare function isFieldEdge(edge: Edge): edge is Edge<FieldMove>;
+export declare function assertFieldEdge(edge: Edge): asserts edge is Edge<FieldMove>;
+export declare class Edge<T = Move> {
+    head: Node;
+    move: T;
+    tail: Node;
+    private resolvable;
+    private _toString;
+    constructor(head: Node, move: T, tail: Node);
+    isCrossGraphEdge(): boolean;
+    toString(): string;
+    getResolvability(graphNames: string[]): EdgeResolvabilityResult | undefined;
+    setResolvable(success: true, graphNames: string[]): EdgeResolvabilityResult;
+    setResolvable(success: false, graphNames: string[], error: SatisfiabilityError): EdgeResolvabilityResult;
+}
+export {};
+//# sourceMappingURL=edge.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/edge.d.ts

@@ -0,0 +1,31 @@
+import { SatisfiabilityError } from './errors';
+import { AbstractMove, EntityMove, FieldMove, Move } from './moves';
+import { Node } from './node';
+type EdgeResolvabilityResult = {
+    success: true;
+    error: undefined;
+} | {
+    success: false;
+    error: SatisfiabilityError;
+};
+export declare function isEntityEdge(edge: Edge): edge is Edge<EntityMove>;
+export declare function assertEntityEdge(edge: Edge): asserts edge is Edge<EntityMove>;
+export declare function isAbstractEdge(edge: Edge): edge is Edge<AbstractMove>;
+export declare function assertAbstractEdge(edge: Edge): asserts edge is Edge<AbstractMove>;
+export declare function isFieldEdge(edge: Edge): edge is Edge<FieldMove>;
+export declare function assertFieldEdge(edge: Edge): asserts edge is Edge<FieldMove>;
+export declare class Edge<T = Move> {
+    head: Node;
+    move: T;
+    tail: Node;
+    private resolvable;
+    private _toString;
+    constructor(head: Node, move: T, tail: Node);
+    isCrossGraphEdge(): boolean;
+    toString(): string;
+    getResolvability(graphNames: string[]): EdgeResolvabilityResult | undefined;
+    setResolvable(success: true, graphNames: string[]): EdgeResolvabilityResult;
+    setResolvable(success: false, graphNames: string[], error: SatisfiabilityError): EdgeResolvabilityResult;
+}
+export {};
+//# sourceMappingURL=edge.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/errors.d.cts

@@ -0,0 +1,17 @@
+type SatisfiabilityErrorKind = 'KEY' | 'REQUIRE' | 'EXTERNAL' | 'MISSING_FIELD' | 'NO_KEY';
+export declare class SatisfiabilityError extends Error {
+    kind: SatisfiabilityErrorKind;
+    sourceGraphName: string;
+    typeName: string;
+    fieldName: string | null;
+    static forKey(sourceGraphName: string, targetGraphName: string, typeName: string, keyFields: string): SatisfiabilityError;
+    static forRequire(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forExternal(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forMissingField(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forNoKey(sourceGraphName: string, targetGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    private constructor();
+    isMatchingField(typeName: string, fieldName: string): boolean;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/errors.d.ts

@@ -0,0 +1,17 @@
+type SatisfiabilityErrorKind = 'KEY' | 'REQUIRE' | 'EXTERNAL' | 'MISSING_FIELD' | 'NO_KEY';
+export declare class SatisfiabilityError extends Error {
+    kind: SatisfiabilityErrorKind;
+    sourceGraphName: string;
+    typeName: string;
+    fieldName: string | null;
+    static forKey(sourceGraphName: string, targetGraphName: string, typeName: string, keyFields: string): SatisfiabilityError;
+    static forRequire(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forExternal(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forMissingField(sourceGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    static forNoKey(sourceGraphName: string, targetGraphName: string, typeName: string, fieldName: string): SatisfiabilityError;
+    private constructor();
+    isMatchingField(typeName: string, fieldName: string): boolean;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/fields.d.cts

@@ -0,0 +1,33 @@
+import { SupergraphState } from '../../../state';
+export type Field = {
+    typeName: string;
+    fieldName: string;
+    selectionSet: null;
+} | {
+    typeName: string;
+    fieldName: string;
+    selectionSet: Array<Field>;
+};
+export declare class Fields {
+    private typeName;
+    private source;
+    fields: Field[];
+    constructor(typeName: string, source: string, fields: Field[]);
+    contains(typeName: string, fieldName: string): boolean;
+    equals(other: Fields): boolean;
+    private _fieldsEqual;
+    private _contains;
+    toString(): string;
+}
+export declare class FieldsResolver {
+    private supergraphState;
+    private cache;
+    constructor(supergraphState: SupergraphState);
+    resolve(typeName: string, keyFields: string): Fields;
+    private keyFactory;
+    private resolveFieldNode;
+    private resolveInlineFragmentNode;
+    private resolveSelectionSetNode;
+    private sortFields;
+}
+//# sourceMappingURL=fields.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/fields.d.ts

@@ -0,0 +1,33 @@
+import { SupergraphState } from '../../../state';
+export type Field = {
+    typeName: string;
+    fieldName: string;
+    selectionSet: null;
+} | {
+    typeName: string;
+    fieldName: string;
+    selectionSet: Array<Field>;
+};
+export declare class Fields {
+    private typeName;
+    private source;
+    fields: Field[];
+    constructor(typeName: string, source: string, fields: Field[]);
+    contains(typeName: string, fieldName: string): boolean;
+    equals(other: Fields): boolean;
+    private _fieldsEqual;
+    private _contains;
+    toString(): string;
+}
+export declare class FieldsResolver {
+    private supergraphState;
+    private cache;
+    constructor(supergraphState: SupergraphState);
+    resolve(typeName: string, keyFields: string): Fields;
+    private keyFactory;
+    private resolveFieldNode;
+    private resolveInlineFragmentNode;
+    private resolveSelectionSetNode;
+    private sortFields;
+}
+//# sourceMappingURL=fields.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/finder.d.cts

@@ -0,0 +1,28 @@
+import type { Logger } from '../../../../utils/logger';
+import { Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import { Fields } from './fields';
+import type { Graph } from './graph';
+import type { MoveValidator } from './move-validator';
+import type { OperationPath } from './operation-path';
+export declare function concatIfNotExistsString(list: string[], item: string): string[];
+export declare function concatIfNotExistsFields(list: Fields[], item: Fields): Fields[];
+type PathFinderResult = {
+    success: true;
+    paths: OperationPath[];
+    errors: undefined;
+} | {
+    success: false;
+    paths: undefined;
+    errors: SatisfiabilityError[];
+};
+export declare class PathFinder {
+    private logger;
+    private graph;
+    private moveValidator;
+    constructor(logger: Logger, graph: Graph, moveValidator: MoveValidator);
+    findDirectPaths(path: OperationPath, typeName: string, fieldName: string | null, visitedEdges: Edge[]): PathFinderResult;
+    findIndirectPaths(path: OperationPath, typeName: string, fieldName: string | null, visitedEdges: Edge[], visitedGraphs: string[], visitedFields: Fields[]): PathFinderResult;
+}
+export {};
+//# sourceMappingURL=finder.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/finder.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '../../../../utils/logger';
+import { Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import { Fields } from './fields';
+import type { Graph } from './graph';
+import type { MoveValidator } from './move-validator';
+import type { OperationPath } from './operation-path';
+export declare function concatIfNotExistsString(list: string[], item: string): string[];
+export declare function concatIfNotExistsFields(list: Fields[], item: Fields): Fields[];
+type PathFinderResult = {
+    success: true;
+    paths: OperationPath[];
+    errors: undefined;
+} | {
+    success: false;
+    paths: undefined;
+    errors: SatisfiabilityError[];
+};
+export declare class PathFinder {
+    private logger;
+    private graph;
+    private moveValidator;
+    constructor(logger: Logger, graph: Graph, moveValidator: MoveValidator);
+    findDirectPaths(path: OperationPath, typeName: string, fieldName: string | null, visitedEdges: Edge[]): PathFinderResult;
+    findIndirectPaths(path: OperationPath, typeName: string, fieldName: string | null, visitedEdges: Edge[], visitedGraphs: string[], visitedFields: Fields[]): PathFinderResult;
+}
+export {};
+//# sourceMappingURL=finder.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/graph.d.cts

@@ -0,0 +1,63 @@
+import type { Logger } from '../../../../utils/logger';
+import type { SupergraphState } from '../../../state';
+import { Edge } from './edge';
+import type { FieldsResolver } from './fields';
+import { Node } from './node';
+export declare class Graph {
+    name: string;
+    private supergraphState;
+    private fieldsResolver;
+    private ignoreInaccessible;
+    private _warnedAboutIncorrectEdge;
+    private nodesByTypeIndex;
+    private edgesByHeadTypeIndex;
+    private edgesByTailTypeIndex;
+    private typeNameToNodeIndexes;
+    private typeChildren;
+    private typeChildrenCache;
+    private isSubgraph;
+    private logger;
+    private id;
+    private idSymbol;
+    constructor(logger: Logger, id: string | Symbol, name: string, supergraphState: SupergraphState, fieldsResolver: FieldsResolver, ignoreInaccessible?: boolean);
+    addUnreachableTypes(): this;
+    addFromRoots(): this;
+    addFromEntities(): this;
+    addSubgraph(graph: Graph): void;
+    private connectUnionOrInterface;
+    private connectEntities;
+    private addProvidedInterfaceFields;
+    private addProvidedField;
+    joinSubgraphs(): this;
+    private duplicateNode;
+    private replaceEdgeAt;
+    print(asLink?: boolean): string;
+    graphNameToId(graphName: string): string | undefined;
+    nodeOf(typeName: string, failIfMissing?: boolean): Node | undefined;
+    nodesOf(typeName: string, failIfMissing?: boolean): Node[];
+    private getSameGraphEdgesOfIndex;
+    fieldEdgesOfHead(head: Node, fieldName: string): Edge[];
+    abstractEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    entityEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    crossGraphEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    edgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    edgesOfTail(tail: Node): Edge<import("./moves").Move>[];
+    possibleTypesOf(typeName: string): string[];
+    canReachTypeFromType(fromTypeName: string, toTypeName: string): boolean;
+    private createNodesAndEdgesForType;
+    private ensureNonOrSingleNode;
+    private createNodesAndEdgesForObjectType;
+    private createNodeForScalarType;
+    private createNodeForEnumType;
+    private createNodeForUnionType;
+    private createNodeForInterfaceType;
+    private createEdgeForObjectTypeField;
+    private createTypeNode;
+    private createNode;
+    private addNode;
+    private addEdge;
+    private getIndexesOfType;
+    private trueOrIfSubgraphThen;
+    private isSupergraph;
+}
+//# sourceMappingURL=graph.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/graph.d.ts

@@ -0,0 +1,63 @@
+import type { Logger } from '../../../../utils/logger';
+import type { SupergraphState } from '../../../state';
+import { Edge } from './edge';
+import type { FieldsResolver } from './fields';
+import { Node } from './node';
+export declare class Graph {
+    name: string;
+    private supergraphState;
+    private fieldsResolver;
+    private ignoreInaccessible;
+    private _warnedAboutIncorrectEdge;
+    private nodesByTypeIndex;
+    private edgesByHeadTypeIndex;
+    private edgesByTailTypeIndex;
+    private typeNameToNodeIndexes;
+    private typeChildren;
+    private typeChildrenCache;
+    private isSubgraph;
+    private logger;
+    private id;
+    private idSymbol;
+    constructor(logger: Logger, id: string | Symbol, name: string, supergraphState: SupergraphState, fieldsResolver: FieldsResolver, ignoreInaccessible?: boolean);
+    addUnreachableTypes(): this;
+    addFromRoots(): this;
+    addFromEntities(): this;
+    addSubgraph(graph: Graph): void;
+    private connectUnionOrInterface;
+    private connectEntities;
+    private addProvidedInterfaceFields;
+    private addProvidedField;
+    joinSubgraphs(): this;
+    private duplicateNode;
+    private replaceEdgeAt;
+    print(asLink?: boolean): string;
+    graphNameToId(graphName: string): string | undefined;
+    nodeOf(typeName: string, failIfMissing?: boolean): Node | undefined;
+    nodesOf(typeName: string, failIfMissing?: boolean): Node[];
+    private getSameGraphEdgesOfIndex;
+    fieldEdgesOfHead(head: Node, fieldName: string): Edge[];
+    abstractEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    entityEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    crossGraphEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    edgesOfHead(head: Node): Edge<import("./moves").Move>[];
+    edgesOfTail(tail: Node): Edge<import("./moves").Move>[];
+    possibleTypesOf(typeName: string): string[];
+    canReachTypeFromType(fromTypeName: string, toTypeName: string): boolean;
+    private createNodesAndEdgesForType;
+    private ensureNonOrSingleNode;
+    private createNodesAndEdgesForObjectType;
+    private createNodeForScalarType;
+    private createNodeForEnumType;
+    private createNodeForUnionType;
+    private createNodeForInterfaceType;
+    private createEdgeForObjectTypeField;
+    private createTypeNode;
+    private createNode;
+    private addNode;
+    private addEdge;
+    private getIndexesOfType;
+    private trueOrIfSubgraphThen;
+    private isSupergraph;
+}
+//# sourceMappingURL=graph.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/helpers.d.cts

@@ -0,0 +1,7 @@
+export declare function occurrences(str: string, subString: string): number;
+export declare function scoreKeyFields(keyFields: string): number;
+export declare function lazy(factory: () => string): {
+    get(): string;
+    invalidate(): void;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function occurrences(str: string, subString: string): number;
+export declare function scoreKeyFields(keyFields: string): number;
+export declare function lazy(factory: () => string): {
+    get(): string;
+    invalidate(): void;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/move-validator.d.cts

@@ -0,0 +1,25 @@
+import type { Logger } from '../../../../utils/logger';
+import { Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import type { Fields } from './fields';
+import type { Graph } from './graph';
+import { OperationPath } from './operation-path';
+export declare class MoveValidator {
+    private supergraph;
+    private cache;
+    private logger;
+    private pathFinder;
+    constructor(logger: Logger, supergraph: Graph);
+    private canResolveFields;
+    private validateRequirement;
+    isExternal(edge: Edge): boolean;
+    private isOverridden;
+    isEdgeResolvable(edge: Edge, path: OperationPath, visitedEdges: Edge[], visitedGraphs: string[], visitedFields: Fields[]): {
+        success: true;
+        error: undefined;
+    } | {
+        success: false;
+        error: SatisfiabilityError;
+    };
+}
+//# sourceMappingURL=move-validator.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/move-validator.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '../../../../utils/logger';
+import { Edge } from './edge';
+import { SatisfiabilityError } from './errors';
+import type { Fields } from './fields';
+import type { Graph } from './graph';
+import { OperationPath } from './operation-path';
+export declare class MoveValidator {
+    private supergraph;
+    private cache;
+    private logger;
+    private pathFinder;
+    constructor(logger: Logger, supergraph: Graph);
+    private canResolveFields;
+    private validateRequirement;
+    isExternal(edge: Edge): boolean;
+    private isOverridden;
+    isEdgeResolvable(edge: Edge, path: OperationPath, visitedEdges: Edge[], visitedGraphs: string[], visitedFields: Fields[]): {
+        success: true;
+        error: undefined;
+    } | {
+        success: false;
+        error: SatisfiabilityError;
+    };
+}
+//# sourceMappingURL=move-validator.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/moves.d.cts

@@ -0,0 +1,24 @@
+import type { Fields } from './fields';
+export interface Move {
+    toString(): string;
+}
+export declare class FieldMove implements Move {
+    typeName: string;
+    fieldName: string;
+    requires: Fields | null;
+    provides: Fields | null;
+    provided: boolean;
+    private _toString;
+    constructor(typeName: string, fieldName: string, requires?: Fields | null, provides?: Fields | null, provided?: boolean);
+    toString(): string;
+}
+export declare class AbstractMove implements Move {
+    toString(): string;
+}
+export declare class EntityMove implements Move {
+    keyFields: Fields;
+    private _toString;
+    constructor(keyFields: Fields);
+    toString(): string;
+}
+//# sourceMappingURL=moves.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/moves.d.ts

@@ -0,0 +1,24 @@
+import type { Fields } from './fields';
+export interface Move {
+    toString(): string;
+}
+export declare class FieldMove implements Move {
+    typeName: string;
+    fieldName: string;
+    requires: Fields | null;
+    provides: Fields | null;
+    provided: boolean;
+    private _toString;
+    constructor(typeName: string, fieldName: string, requires?: Fields | null, provides?: Fields | null, provided?: boolean);
+    toString(): string;
+}
+export declare class AbstractMove implements Move {
+    toString(): string;
+}
+export declare class EntityMove implements Move {
+    keyFields: Fields;
+    private _toString;
+    constructor(keyFields: Fields);
+    toString(): string;
+}
+//# sourceMappingURL=moves.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/node.d.cts

@@ -0,0 +1,31 @@
+import type { EnumTypeState } from '../../../composition/enum-type';
+import type { InterfaceTypeState } from '../../../composition/interface-type';
+import type { ObjectTypeState } from '../../../composition/object-type';
+import type { ScalarTypeState } from '../../../composition/scalar-type';
+import type { UnionTypeState } from '../../../composition/union-type';
+export declare class Node {
+    index: number;
+    typeName: string;
+    typeState: ObjectTypeState | InterfaceTypeState | EnumTypeState | ScalarTypeState | UnionTypeState | null;
+    graphId: string;
+    graphName: string;
+    private _toString;
+    isLeaf: boolean;
+    private childrenIndex;
+    private visitedGraphCombos;
+    constructor(index: number, typeName: string, typeState: ObjectTypeState | InterfaceTypeState | EnumTypeState | ScalarTypeState | UnionTypeState | null, graphId: string, graphName: string);
+    withoutState(): this;
+    addFieldEdge(fieldName: string, edgeAt: number): void;
+    getFieldEdgeIndexes(fieldName: string): number[] | undefined;
+    addEntityEdge(typeName: string, edgeAt: number): void;
+    getEntityEdgeIndexes(typeName: string): number[] | undefined;
+    addAbstractEdge(typeName: string, edgeAt: number): void;
+    getAbstractEdgeIndexes(typeName: string): number[] | undefined;
+    addCrossGraphEdge(typeName: string, edgeAt: number): void;
+    getCrossGraphEdgeIndexes(typeName: string): number[] | undefined;
+    private pushToChildrenIndex;
+    isGraphComboVisited(graphNameProvidesCombos: string[]): boolean;
+    setGraphComboAsVisited(graphNames: string[]): void;
+    toString(): string;
+}
+//# sourceMappingURL=node.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/node.d.ts

@@ -0,0 +1,31 @@
+import type { EnumTypeState } from '../../../composition/enum-type';
+import type { InterfaceTypeState } from '../../../composition/interface-type';
+import type { ObjectTypeState } from '../../../composition/object-type';
+import type { ScalarTypeState } from '../../../composition/scalar-type';
+import type { UnionTypeState } from '../../../composition/union-type';
+export declare class Node {
+    index: number;
+    typeName: string;
+    typeState: ObjectTypeState | InterfaceTypeState | EnumTypeState | ScalarTypeState | UnionTypeState | null;
+    graphId: string;
+    graphName: string;
+    private _toString;
+    isLeaf: boolean;
+    private childrenIndex;
+    private visitedGraphCombos;
+    constructor(index: number, typeName: string, typeState: ObjectTypeState | InterfaceTypeState | EnumTypeState | ScalarTypeState | UnionTypeState | null, graphId: string, graphName: string);
+    withoutState(): this;
+    addFieldEdge(fieldName: string, edgeAt: number): void;
+    getFieldEdgeIndexes(fieldName: string): number[] | undefined;
+    addEntityEdge(typeName: string, edgeAt: number): void;
+    getEntityEdgeIndexes(typeName: string): number[] | undefined;
+    addAbstractEdge(typeName: string, edgeAt: number): void;
+    getAbstractEdgeIndexes(typeName: string): number[] | undefined;
+    addCrossGraphEdge(typeName: string, edgeAt: number): void;
+    getCrossGraphEdgeIndexes(typeName: string): number[] | undefined;
+    private pushToChildrenIndex;
+    isGraphComboVisited(graphNameProvidesCombos: string[]): boolean;
+    setGraphComboAsVisited(graphNames: string[]): void;
+    toString(): string;
+}
+//# sourceMappingURL=node.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/operation-path.d.cts

@@ -0,0 +1,29 @@
+import { type Edge } from './edge';
+import type { Node } from './node';
+export type Step = FieldStep | AbstractStep;
+export type FieldStep = {
+    fieldName: string;
+    typeName: string;
+};
+export type AbstractStep = {
+    typeName: string;
+};
+export declare class OperationPath {
+    private _rootNode;
+    private _toString;
+    private previousNodes;
+    private previousEdges;
+    private previousSteps;
+    constructor(_rootNode: Node);
+    move(edge: Edge): OperationPath;
+    clone(): OperationPath;
+    depth(): number;
+    edge(): Edge | undefined;
+    steps(): Step[];
+    tail(): Node | undefined;
+    rootNode(): Node;
+    isVisitedEdge(edge: Edge): boolean;
+    toString(): string;
+    private advance;
+}
+//# sourceMappingURL=operation-path.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/operation-path.d.ts

@@ -0,0 +1,29 @@
+import { type Edge } from './edge';
+import type { Node } from './node';
+export type Step = FieldStep | AbstractStep;
+export type FieldStep = {
+    fieldName: string;
+    typeName: string;
+};
+export type AbstractStep = {
+    typeName: string;
+};
+export declare class OperationPath {
+    private _rootNode;
+    private _toString;
+    private previousNodes;
+    private previousEdges;
+    private previousSteps;
+    constructor(_rootNode: Node);
+    move(edge: Edge): OperationPath;
+    clone(): OperationPath;
+    depth(): number;
+    edge(): Edge | undefined;
+    steps(): Step[];
+    tail(): Node | undefined;
+    rootNode(): Node;
+    isVisitedEdge(edge: Edge): boolean;
+    toString(): string;
+    private advance;
+}
+//# sourceMappingURL=operation-path.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/supergraph.d.cts

@@ -0,0 +1,14 @@
+import { OperationTypeNode } from 'graphql';
+import type { SupergraphState } from '../../../state';
+import { Step } from './operation-path';
+export declare class Supergraph {
+    private supergraph;
+    private mergedGraph;
+    private fieldsResolver;
+    private moveRequirementChecker;
+    private logger;
+    constructor(supergraphState: SupergraphState);
+    validate(): import("./walker").WalkTracker[];
+    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker").WalkTracker;
+}
+//# sourceMappingURL=supergraph.d.ts.map