@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -4,22 +4,14 @@ import { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
-interface RelatedNodeShapes {
-    readonly ancestors: input.NodeShape[];
-    readonly children: input.NodeShape[];
-    readonly parents: input.NodeShape[];
-    readonly descendants: input.NodeShape[];
-}
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
     protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
-    protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     constructor({ logger, shapesGraph, }: {
         logger: Logger;
         shapesGraph: input.ShapesGraph;
     });
     transform(): Either<Error, ast.Ast>;
 }
-export {};
 //# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/dist/ShapesGraphToAstTransformer.js

@@ -4,92 +4,18 @@ import { Either } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
-function relatedNodeShapes({ logger, shapesGraph, }) {
-    const immediateRelatedNodeShapes = new TermMap();
-    for (const childNodeShape of shapesGraph.nodeShapes) {
-        let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier());
-        if (!childRelatedNodeShapes) {
-            childRelatedNodeShapes = {
-                children: new TermMap(),
-                parents: new TermMap(),
-            };
-            immediateRelatedNodeShapes.set(childNodeShape.$identifier(), childRelatedNodeShapes);
-        }
-        for (const parentClassIdentifier of childNodeShape.subClassOf) {
-            shapesGraph
-                .nodeShape(parentClassIdentifier)
-                .ifLeft((error) => {
-                logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, parentClassIdentifier, error.message);
-            })
-                .ifRight((parentNodeShape) => {
-                childRelatedNodeShapes.parents.set(parentNodeShape.$identifier(), parentNodeShape);
-                let parentRelatedNodeShapes = immediateRelatedNodeShapes.get(parentNodeShape.$identifier());
-                if (!parentRelatedNodeShapes) {
-                    parentRelatedNodeShapes = {
-                        children: new TermMap(),
-                        parents: new TermMap(),
-                    };
-                    immediateRelatedNodeShapes.set(parentNodeShape.$identifier(), parentRelatedNodeShapes);
-                }
-                parentRelatedNodeShapes.children.set(childNodeShape.$identifier(), childNodeShape);
-            });
-        }
-    }
-    const result = new TermMap();
-    for (const nodeShape of shapesGraph.nodeShapes) {
-        const { children: childNodeShapes, parents: parentNodeShapes } = immediateRelatedNodeShapes.get(nodeShape.$identifier());
-        const ancestorNodeShapes = new TermMap();
-        function recurseAncestorNodeShapes(nodeShape) {
-            for (const parentNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier())
-                .parents.values()) {
-                if (!ancestorNodeShapes.has(parentNodeShape.$identifier())) {
-                    ancestorNodeShapes.set(parentNodeShape.$identifier(), parentNodeShape);
-                    recurseAncestorNodeShapes(parentNodeShape);
-                }
-            }
-        }
-        recurseAncestorNodeShapes(nodeShape);
-        const descendantNodeShapes = new TermMap();
-        function recurseDescendantNodeShapes(nodeShape) {
-            for (const childNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier())
-                .children.values()) {
-                if (!descendantNodeShapes.has(childNodeShape.$identifier())) {
-                    descendantNodeShapes.set(childNodeShape.$identifier(), childNodeShape);
-                    recurseDescendantNodeShapes(childNodeShape);
-                }
-            }
-        }
-        recurseDescendantNodeShapes(nodeShape);
-        result.set(nodeShape.$identifier(), {
-            ancestors: [...ancestorNodeShapes.values()],
-            children: [...childNodeShapes.values()],
-            descendants: [...descendantNodeShapes.values()],
-            parents: [...parentNodeShapes.values()],
-        });
-    }
-    return result;
-}
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
     logger;
     shapesGraph;
-    relatedNodeShapesByIdentifier = new TermMap();
     constructor({ logger, shapesGraph, }) {
         this.logger = logger;
-        this.relatedNodeShapesByIdentifier = relatedNodeShapes({
-            logger: this.logger,
-            shapesGraph,
-        });
         this.shapesGraph = shapesGraph;
     }
     transform() {
-        const astNamedIntersectionTypes = [];
-        const astObjectTypes = [];
+        const astNamedTypes = [];
         const syntheticAstObjectTypesByName = {};
-        const astNamedUnionTypes = [];
         for (const nodeShape of this.shapesGraph.nodeShapes) {
             if (nodeShape.$identifier().termType !== "NamedNode") {
                 continue;
@@ -104,13 +30,14 @@ export class ShapesGraphToAstTransformer {
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
             switch (nodeShapeAstType.kind) {
                 case "Intersection":
+                case "Union":
                     if (nodeShapeAstType.name.isJust()) {
-                        astNamedIntersectionTypes.push(nodeShapeAstType);
+                        astNamedTypes.push(nodeShapeAstType);
                     }
                     break;
                 case "Object": {
                     invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
-                    astObjectTypes.push(nodeShapeAstType);
+                    astNamedTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
                         switch (property.type.kind) {
                             case "LazyObjectOption":
@@ -133,11 +60,6 @@ export class ShapesGraphToAstTransformer {
                     }
                     break;
                 }
-                case "Union":
-                    if (nodeShapeAstType.name.isJust()) {
-                        astNamedUnionTypes.push(nodeShapeAstType);
-                    }
-                    break;
                 default:
                     break;
             }
@@ -153,9 +75,7 @@ export class ShapesGraphToAstTransformer {
                         return acc;
                 }
             }, 0),
-            namedIntersectionTypes: astNamedIntersectionTypes,
-            namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
-            namedUnionTypes: astNamedUnionTypes,
+            namedTypes: astNamedTypes.concat(Object.values(syntheticAstObjectTypesByName)),
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -6,177 +6,145 @@ const defaultPropertyShapeNodeKinds = new Set([
     "IRI",
     "Literal",
 ]);
-function nodeShapeNodeKinds(nodeShape) {
-    const thisNodeKinds = nodeShape.nodeKind
+export function shapeNodeKinds(shape, options) {
+    const explicitNodeKinds = shape.nodeKind
         .map(NodeKind.fromIri)
         .orDefault(new Set());
-    // Recurse into parents
-    const parentNodeKinds = new Set();
-    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier()).parents) {
-        nodeShapeNodeKinds
-            .call(this, parentNodeShape)
-            .ifRight((parentNodeKinds_) => {
-            for (const parentNodeKind of parentNodeKinds_) {
-                parentNodeKinds.add(parentNodeKind);
+    // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
+    const constraintExcludeNodeKinds = new Set();
+    const constraintIncludeNodeKinds = new Set();
+    for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
+        [
+            "sh:class",
+            shape.classes.length > 0
+                ? { excludeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:datatype",
+            {
+                includeNodeKinds: shape.datatype
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:defaultValue",
+            {
+                includeNodeKinds: shape.$type === "PropertyShape"
+                    ? shape.defaultValue
+                        .map((value) => NodeKind.fromTermType(value.termType))
+                        .toList()
+                    : [],
+            },
+        ],
+        [
+            "sh:hasValue",
+            {
+                includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
+            },
+        ],
+        [
+            "sh:in",
+            {
+                includeNodeKinds: shape.in_
+                    .orDefault([])
+                    .map((in_) => NodeKind.fromTermType(in_.termType)),
+            },
+        ],
+        [
+            "sh:languageIn",
+            shape.languageIn.orDefault([]).length > 0
+                ? { includeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:maxExclusive",
+            {
+                includeNodeKinds: shape.maxExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:maxInclusive",
+            {
+                includeNodeKinds: shape.maxInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minExclusive",
+            {
+                includeNodeKinds: shape.minExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minInclusive",
+            {
+                includeNodeKinds: shape.minInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+    ]) {
+        for (const excludeNodeKind of excludeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                explicitNodeKinds.has(excludeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
             }
-        });
-    }
-    if (parentNodeKinds.size > 0) {
-        if (thisNodeKinds.size === 0) {
-            return Either.of(parentNodeKinds);
+            constraintExcludeNodeKinds.add(excludeNodeKind);
         }
-        // Check that thisNodeKinds doesn't conflict with parent node kinds
-        for (const thisNodeKind of thisNodeKinds) {
-            if (!parentNodeKinds.has(thisNodeKind)) {
-                return Left(new Error(`${nodeShape} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`));
+        for (const includeNodeKind of includeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                !explicitNodeKinds.has(includeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
             }
+            constraintIncludeNodeKinds.add(includeNodeKind);
         }
     }
-    return Either.of(thisNodeKinds);
-}
-function propertyShapeNodeKinds(propertyShape) {
-    return Either.of(propertyShape.nodeKind.map(NodeKind.fromIri).orDefault(new Set()));
-}
-export function shapeNodeKinds(shape, options) {
-    return (shape.$type === "NodeShape"
-        ? nodeShapeNodeKinds.call(this, shape)
-        : propertyShapeNodeKinds(shape)).chain((explicitNodeKinds) => {
-        // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
-        const constraintExcludeNodeKinds = new Set();
-        const constraintIncludeNodeKinds = new Set();
-        for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
-            [
-                "sh:class",
-                shape.classes.length > 0
-                    ? { excludeNodeKinds: ["Literal"] }
-                    : {},
-            ],
-            [
-                "sh:datatype",
-                {
-                    includeNodeKinds: shape.datatype
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:defaultValue",
-                {
-                    includeNodeKinds: shape.$type === "PropertyShape"
-                        ? shape.defaultValue
-                            .map((value) => NodeKind.fromTermType(value.termType))
-                            .toList()
-                        : [],
-                },
-            ],
-            [
-                "sh:hasValue",
-                {
-                    includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
-                },
-            ],
-            [
-                "sh:in",
-                {
-                    includeNodeKinds: shape.in_
-                        .orDefault([])
-                        .map((in_) => NodeKind.fromTermType(in_.termType)),
-                },
-            ],
-            [
-                "sh:languageIn",
-                shape.languageIn.orDefault([]).length > 0
-                    ? { includeNodeKinds: ["Literal"] }
-                    : {},
-            ],
-            [
-                "sh:maxExclusive",
-                {
-                    includeNodeKinds: shape.maxExclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:maxInclusive",
-                {
-                    includeNodeKinds: shape.maxInclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:minExclusive",
-                {
-                    includeNodeKinds: shape.minExclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-            [
-                "sh:minInclusive",
-                {
-                    includeNodeKinds: shape.minInclusive
-                        .map(() => ["Literal"])
-                        .orDefault([]),
-                },
-            ],
-        ]) {
-            for (const excludeNodeKind of excludeNodeKinds ?? []) {
-                if (explicitNodeKinds.size > 0 &&
-                    explicitNodeKinds.has(excludeNodeKind)) {
-                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
-                }
-                constraintExcludeNodeKinds.add(excludeNodeKind);
-            }
-            for (const includeNodeKind of includeNodeKinds ?? []) {
-                if (explicitNodeKinds.size > 0 &&
-                    !explicitNodeKinds.has(includeNodeKind)) {
-                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
-                }
-                constraintIncludeNodeKinds.add(includeNodeKind);
-            }
-        }
-        if (explicitNodeKinds.size > 0) {
-            return Either.of(explicitNodeKinds);
-        }
-        // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
-        const constraintNodeKinds = new Set();
-        if (constraintIncludeNodeKinds.size > 0) {
-            // If constraints dictated/included certain node kinds be included. Add those to the set.
-            for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
-                constraintNodeKinds.add(constraintIncludeNodeKind);
-            }
-            // Check whether other constraints' excluded node kinds conflict.
-            if (constraintExcludeNodeKinds.size > 0) {
-                for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
-                    if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
-                        return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
-                    }
-                }
-            }
+    if (explicitNodeKinds.size > 0) {
+        return Either.of(explicitNodeKinds);
+    }
+    // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
+    const constraintNodeKinds = new Set();
+    if (constraintIncludeNodeKinds.size > 0) {
+        // If constraints dictated/included certain node kinds be included. Add those to the set.
+        for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
+            constraintNodeKinds.add(constraintIncludeNodeKind);
         }
-        else if (constraintExcludeNodeKinds.size > 0) {
-            // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
-            // Start with all node kinds and exclude.
-            constraintNodeKinds.add("BlankNode");
-            constraintNodeKinds.add("IRI");
-            constraintNodeKinds.add("Literal");
+        // Check whether other constraints' excluded node kinds conflict.
+        if (constraintExcludeNodeKinds.size > 0) {
             for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
-                constraintNodeKinds.delete(constraintExcludeNodeKind);
+                if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
+                    return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
+                }
             }
         }
-        if (constraintNodeKinds.size > 0) {
-            return Either.of(constraintNodeKinds);
-        }
-        if (shape.$type === "NodeShape") {
-            return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
-        }
-        if (shape.path.termType === "InversePath") {
-            // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
-            return Either.of(new Set(["BlankNode", "IRI"]));
+    }
+    else if (constraintExcludeNodeKinds.size > 0) {
+        // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
+        // Start with all node kinds and exclude.
+        constraintNodeKinds.add("BlankNode");
+        constraintNodeKinds.add("IRI");
+        constraintNodeKinds.add("Literal");
+        for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+            constraintNodeKinds.delete(constraintExcludeNodeKind);
         }
-        return Either.of(defaultPropertyShapeNodeKinds);
-    });
+    }
+    if (constraintNodeKinds.size > 0) {
+        return Either.of(constraintNodeKinds);
+    }
+    if (shape.$type === "NodeShape") {
+        return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
+    }
+    if (shape.path.termType === "InversePath") {
+        // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
+        return Either.of(new Set(["BlankNode", "IRI"]));
+    }
+    return Either.of(defaultPropertyShapeNodeKinds);
 }
 //# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.d.ts

@@ -2,6 +2,6 @@ import { Either, Maybe } from "purify-ts";
 import * as ast from "../ast/index.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import { ShapeStack } from "./ShapeStack.js";
+import type { ShapeStack } from "./ShapeStack.js";
 export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
 //# sourceMappingURL=transformShapeToAstObjectType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -4,7 +4,6 @@ import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
-import { ShapeStack } from "./ShapeStack.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
@@ -61,9 +60,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
         }
         return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier)))).chain(([nodeKinds, propertyShapes]) => {
             const nodeShapeIdentifier = nodeShape.$identifier();
-            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShapeIdentifier);
             const isClass = nodeShape.subClassOf.length > 0 ||
-                descendantNodeShapes.length > 0 || // A node shape that is the object of an rdfs:subClassOf is itself an rdfs:Class
                 nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
             let fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
             if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
@@ -131,19 +128,6 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             });
             this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), objectType);
             return (() => {
-                // Populate ancestor and descendant object types
-                const relatedObjectTypes = (relatedNodeShapes) => {
-                    return relatedNodeShapes
-                        .flatMap((relatedNodeShape) => transformShapeToAstType
-                        .call(this, relatedNodeShape, new ShapeStack())
-                        .toMaybe()
-                        .toList())
-                        .filter((astType) => astType.kind === "Object");
-                };
-                objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
-                objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
-                objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
-                objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
                 // Populate properties
                 for (const propertyShape of propertyShapes) {
                     const propertyEither = transformPropertyShapeToAstObjectTypeProperty.call(this, {

package/dist/ast/AbstractCompoundType.d.ts

@@ -4,6 +4,7 @@ import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
+import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { TermType } from "./TermType.js";
@@ -38,7 +39,7 @@ export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {
         readonly type: TypeT;
     }
-    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectType | TermType | UnionType;
+    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;
     function isMemberType(type: Type): type is MemberType;
 }
 //# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -61,6 +61,7 @@ __decorate([
             case "Identifier":
             case "Intersection":
             case "Iri":
+            case "List":
             case "Literal":
             case "Object":
             case "Term":
@@ -70,7 +71,6 @@ __decorate([
             case "LazyObjectOption":
             case "LazyObjectSet":
             case "LazyObject":
-            case "List":
             case "Option":
             case "Set":
                 return false;

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -32,7 +32,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
                 recursive: boolean | undefined;
                 shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;
@@ -74,7 +73,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
                 recursive: boolean | undefined;
                 shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;

package/dist/ast/Ast.d.ts

@@ -3,8 +3,6 @@ import type { ObjectType } from "./ObjectType.js";
 import type { UnionType } from "./UnionType.js";
 export interface Ast {
     readonly lazyTypesCount: number;
-    readonly namedIntersectionTypes: readonly IntersectionType[];
-    readonly namedObjectTypes: readonly ObjectType[];
-    readonly namedUnionTypes: readonly UnionType[];
+    readonly namedTypes: readonly (IntersectionType | ObjectType | UnionType)[];
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/ListType.d.ts

@@ -38,7 +38,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
     equals(other: ListType<ItemTypeT>): boolean;
 }
 export declare namespace ListType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -36,6 +36,7 @@ export class ListType extends AbstractCollectionType {
             case "Identifier":
             case "Intersection":
             case "Iri":
+            case "List":
             case "Literal":
             case "Object":
             case "Term":
@@ -45,7 +46,6 @@ export class ListType extends AbstractCollectionType {
             case "LazyObjectOption":
             case "LazyObjectSet":
             case "LazyObject":
-            case "List":
             case "Option":
             case "Set":
                 return false;

package/dist/ast/ObjectType.d.ts

@@ -59,16 +59,8 @@ export declare class ObjectType extends AbstractType {
         toRdfTypes: readonly NamedNode[];
         tsImports: readonly string[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
-    get descendantObjectTypes(): readonly ObjectType[];
-    get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
     get recursive(): boolean;
-    addAncestorObjectTypes(...ancestorObjectTypes: readonly ObjectType[]): void;
-    addChildObjectTypes(...childObjectTypes: readonly ObjectType[]): void;
-    addDescendantObjectTypes(...descendantObjectTypes: readonly ObjectType[]): void;
-    addParentObjectTypes(...parentObjectTypes: readonly ObjectType[]): void;
     addProperties(...properties: readonly ObjectType.Property[]): void;
     equals(other: ObjectType): boolean;
     sortProperties(): void;
@@ -85,7 +77,6 @@ export declare class ObjectType extends AbstractType {
             recursive: boolean | undefined;
             shapeIdentifier: BlankNode | NamedNode<string>;
         };
-        parentObjectTypes: (string | BlankNode | NamedNode<string>)[] | undefined;
         synthetic: boolean | undefined;
         toRdfTypes: readonly NamedNode<string>[] | undefined;
         comment: string | undefined;
@@ -183,7 +174,4 @@ export declare namespace ObjectType {
         toString(): string;
     }
 }
-export declare namespace ObjectType {
-    function toposort(objectTypes: readonly ObjectType[]): readonly ObjectType[];
-}
 //# sourceMappingURL=ObjectType.d.ts.map