@shaclmate/shacl-ast 2.0.13 → 2.0.14

package/RdfjsShapesGraph.js

@@ -0,0 +1,239 @@
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { owl, sh } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { ResourceSet } from "rdfjs-resource";
+export class RdfjsShapesGraph {
+    constructor({ dataset, factory, }) {
+        this.dataset = dataset;
+        this.resourceSet = new ResourceSet({ dataset: this.dataset });
+        this.node = this.readGraph();
+        const { nodeShapes, nodeShapesByIdentifier, propertyShapes, propertyShapesByIdentifier, } = this.readShapes(factory);
+        this.nodeShapes = nodeShapes;
+        this.nodeShapesByIdentifier = nodeShapesByIdentifier;
+        this.propertyShapes = propertyShapes;
+        this.propertyShapesByIdentifier = propertyShapesByIdentifier;
+        const { ontologies, ontologiesByIdentifier } = this.readOntologies(factory);
+        this.ontologies = ontologies;
+        this.ontologiesByIdentifier = ontologiesByIdentifier;
+        const { propertyGroups, propertyGroupsByIdentifier } = this.readPropertyGroups(factory);
+        this.propertyGroups = propertyGroups;
+        this.propertyGroupsByIdentifier = propertyGroupsByIdentifier;
+    }
+    nodeShapeByIdentifier(nodeShapeNode) {
+        return Maybe.fromNullable(this.nodeShapesByIdentifier.get(nodeShapeNode));
+    }
+    ontologyByIdentifier(identifier) {
+        return Maybe.fromNullable(this.ontologiesByIdentifier.get(identifier));
+    }
+    propertyGroupByIdentifier(identifier) {
+        return Maybe.fromNullable(this.propertyGroupsByIdentifier.get(identifier));
+    }
+    propertyShapeByIdentifier(identifier) {
+        return Maybe.fromNullable(this.propertyShapesByIdentifier.get(identifier));
+    }
+    shapeByIdentifier(identifier) {
+        const nodeShape = this.nodeShapeByIdentifier(identifier);
+        if (nodeShape.isJust()) {
+            return nodeShape;
+        }
+        return this.propertyShapeByIdentifier(identifier);
+    }
+    readGraph() {
+        const graphs = new TermSet();
+        for (const quad of this.dataset) {
+            graphs.add(quad.graph);
+        }
+        if (graphs.size !== 1) {
+            return null;
+        }
+        const graph = [...graphs.values()][0];
+        switch (graph.termType) {
+            case "BlankNode":
+            case "DefaultGraph":
+            case "NamedNode":
+                return graph;
+            default:
+                throw new RangeError(`expected NamedNode or default graph, actual ${graph.termType}`);
+        }
+    }
+    readOntologies(factory) {
+        const ontologies = [];
+        const ontologiesByIdentifier = new TermMap();
+        for (const ontologyResource of this.resourceSet.instancesOf(owl.Ontology, {
+            graph: this.node,
+        })) {
+            if (ontologiesByIdentifier.has(ontologyResource.identifier)) {
+                continue;
+            }
+            factory
+                .ontologyFromRdf({
+                resource: ontologyResource,
+                shapesGraph: this,
+            })
+                .ifRight((ontology) => {
+                ontologies.push(ontology);
+                ontologiesByIdentifier.set(ontologyResource.identifier, ontology);
+            });
+        }
+        return { ontologies, ontologiesByIdentifier };
+    }
+    readPropertyGroups(factory) {
+        const propertyGroups = [];
+        const propertyGroupsByIdentifier = new TermMap();
+        for (const propertyGroupResource of this.resourceSet.instancesOf(sh.PropertyGroup, { graph: this.node })) {
+            if (propertyGroupResource.identifier.termType !== "NamedNode") {
+                continue;
+            }
+            if (propertyGroupsByIdentifier.has(propertyGroupResource.identifier)) {
+                continue;
+            }
+            factory
+                .propertyGroupFromRdf({
+                resource: propertyGroupResource,
+                shapesGraph: this,
+            })
+                .ifRight((propertyGroup) => {
+                propertyGroups.push(propertyGroup);
+                propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup);
+            });
+        }
+        return { propertyGroups, propertyGroupsByIdentifier };
+    }
+    readShapes(factory) {
+        // Collect the shape identifiers in sets
+        const shapeNodeSet = new TermSet();
+        // Utility function for doing the collection
+        const addShapeNode = (shapeNode) => {
+            switch (shapeNode.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    shapeNodeSet.add(shapeNode);
+                    break;
+            }
+        };
+        // Test each shape condition
+        // https://www.w3.org/TR/shacl/#shapes
+        // Subject is a SHACL instance of sh:NodeShape or sh:PropertyShape
+        for (const rdfType of [sh.NodeShape, sh.PropertyShape]) {
+            for (const resource of this.resourceSet.instancesOf(rdfType, {
+                graph: this.node,
+            })) {
+                addShapeNode(resource.identifier);
+            }
+        }
+        // Subject of a triple with sh:targetClass, sh:targetNode, sh:targetObjectsOf, or sh:targetSubjectsOf predicate
+        for (const predicate of [
+            sh.targetClass,
+            sh.targetNode,
+            sh.targetObjectsOf,
+            sh.targetSubjectsOf,
+        ]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.subject);
+            }
+        }
+        // Subject of a triple that has a parameter as predicate
+        // https://www.w3.org/TR/shacl/#constraints
+        // https://www.w3.org/TR/shacl/#core-components
+        for (const predicate of [
+            sh.class,
+            sh.datatype,
+            sh.nodeKind,
+            sh.minCount,
+            sh.maxCount,
+            sh.minExclusive,
+            sh.minInclusive,
+            sh.maxExclusive,
+            sh.maxInclusive,
+            sh.minLength,
+            sh.maxLength,
+            sh.pattern,
+            sh.languageIn,
+            sh.uniqueLang,
+            sh.equals,
+            sh.disjoint,
+            sh.lessThan,
+            sh.lessThanOrEquals,
+            sh.not,
+            sh.and,
+            sh.or,
+            sh.xone,
+            sh.node,
+            sh.property,
+            sh.qualifiedValueShape,
+            sh.qualifiedMinCount,
+            sh.qualifiedMaxCount,
+            sh.closed,
+            sh.ignoredProperties,
+            sh.hasValue,
+            sh.in,
+        ]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.subject);
+            }
+        }
+        // Object of a shape-expecting, non-list-taking parameter such as sh:node
+        for (const predicate of [sh.node, sh.property]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.object);
+            }
+        }
+        // Member of a SHACL list that is a value of a shape-expecting and list-taking parameter such as sh:or
+        for (const predicate of [sh.and, sh.or, sh.xone]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                switch (quad.object.termType) {
+                    case "BlankNode":
+                    case "NamedNode":
+                        break;
+                    default:
+                        continue;
+                }
+                for (const value of this.resourceSet
+                    .resource(quad.object)
+                    .toList()
+                    .orDefault([])) {
+                    value.toIdentifier().ifRight(addShapeNode);
+                }
+            }
+        }
+        // Separate shapes into node and property shapes.
+        const nodeShapes = [];
+        const nodeShapesByIdentifier = new TermMap();
+        const propertyShapes = [];
+        const propertyShapesByIdentifier = new TermMap();
+        for (const shapeNode of shapeNodeSet) {
+            if (this.dataset.match(shapeNode, sh.path, null, this.node).size > 0) {
+                // A property shape is a shape in the shapes graph that is the subject of a triple that has sh:path as its predicate. A shape has at most one value for sh:path. Each value of sh:path in a shape must be a well-formed SHACL property path. It is recommended, but not required, for a property shape to be declared as a SHACL instance of sh:PropertyShape. SHACL instances of sh:PropertyShape have one value for the property sh:path.
+                factory
+                    .propertyShapeFromRdf({
+                    resource: this.resourceSet.resource(shapeNode),
+                    shapesGraph: this,
+                })
+                    .ifRight((propertyShape) => {
+                    propertyShapes.push(propertyShape);
+                    propertyShapesByIdentifier.set(shapeNode, propertyShape);
+                });
+            }
+            else {
+                // A node shape is a shape in the shapes graph that is not the subject of a triple with sh:path as its predicate. It is recommended, but not required, for a node shape to be declared as a SHACL instance of sh:NodeShape. SHACL instances of sh:NodeShape cannot have a value for the property sh:path.
+                factory
+                    .nodeShapeFromRdf({
+                    resource: this.resourceSet.resource(shapeNode),
+                    shapesGraph: this,
+                })
+                    .ifRight((nodeShape) => {
+                    nodeShapes.push(nodeShape);
+                    nodeShapesByIdentifier.set(shapeNode, nodeShape);
+                });
+            }
+        }
+        return {
+            nodeShapes,
+            nodeShapesByIdentifier,
+            propertyShapes,
+            propertyShapesByIdentifier,
+        };
+    }
+}
+//# sourceMappingURL=RdfjsShapesGraph.js.map

package/Shape.d.ts

@@ -1,47 +1,42 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
-import { NodeKind } from "./NodeKind.js";
-import type { NodeShape } from "./NodeShape.js";
+import { Maybe } from "purify-ts";
+import type { NodeKind } from "./NodeKind.js";
+import type { OntologyLike } from "./OntologyLike.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-export declare abstract class Shape {
-    readonly resource: Resource;
-    abstract readonly constraints: Shape.Constraints;
-    readonly targets: Shape.Targets;
-    protected constructor(resource: Resource);
-    get description(): Maybe<Literal>;
-    get name(): Maybe<Literal>;
+import type * as generated from "./generated.js";
+export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    private readonly generatedShaclCoreShape;
+    protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    abstract readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    get comments(): readonly Literal[];
+    get identifier(): BlankNode | NamedNode;
+    get isDefinedBy(): Maybe<OntologyT>;
+    get labels(): readonly Literal[];
 }
 export declare namespace Shape {
-    class Constraints {
-        protected readonly resource: Resource;
-        protected readonly shapesGraph: ShapesGraph;
-        constructor(resource: Resource, shapesGraph: ShapesGraph);
-        get and(): readonly Shape[];
+    class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+        private readonly generatedShaclCoreShape;
+        protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+        constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+        get and(): readonly ShapeT[];
         get classes(): readonly NamedNode[];
         get datatype(): Maybe<NamedNode>;
-        get hasValue(): Maybe<BlankNode | Literal | NamedNode>;
-        get in_(): Maybe<readonly (BlankNode | Literal | NamedNode)[]>;
+        get hasValues(): readonly (BlankNode | Literal | NamedNode)[];
+        get in_(): readonly (BlankNode | Literal | NamedNode)[];
+        get languageIn(): readonly string[];
         get maxCount(): Maybe<number>;
         get maxExclusive(): Maybe<Literal>;
         get maxInclusive(): Maybe<Literal>;
         get minCount(): Maybe<number>;
         get minExclusive(): Maybe<Literal>;
         get minInclusive(): Maybe<Literal>;
-        get nodeKinds(): Set<NodeKind>;
-        get nodes(): readonly NodeShape[];
-        get not(): readonly Shape[];
-        get or(): readonly Shape[];
-        get xone(): readonly Shape[];
-        private listTakingLogicalConstraint;
-    }
-    class Targets {
-        protected readonly resource: Resource;
-        constructor(resource: Resource);
-        get targetClasses(): readonly NamedNode[];
-        get targetNodes(): readonly (Literal | NamedNode)[];
-        get targetObjectsOf(): readonly NamedNode[];
-        get targetSubjectsOf(): readonly NamedNode[];
+        get nodeKinds(): Maybe<Set<NodeKind>>;
+        get nodes(): readonly NodeShapeT[];
+        get not(): readonly ShapeT[];
+        get or(): readonly ShapeT[];
+        get xone(): readonly ShapeT[];
+        private shapeListTakingConstraint;
     }
 }
 //# sourceMappingURL=Shape.d.ts.map

package/Shape.js

@@ -1,171 +1,127 @@
-import { sh } from "@tpluscode/rdf-ns-builders";
-import { NodeKind } from "./NodeKind.js";
+import { Maybe } from "purify-ts";
 export class Shape {
-    constructor(resource) {
-        this.resource = resource;
-        this.targets = new Shape.Targets(resource);
+    constructor(generatedShaclCoreShape, shapesGraph) {
+        this.generatedShaclCoreShape = generatedShaclCoreShape;
+        this.shapesGraph = shapesGraph;
     }
-    get description() {
-        return this.resource
-            .value(sh.description)
-            .chain((value) => value.toLiteral())
-            .toMaybe();
+    get comments() {
+        return this.generatedShaclCoreShape.comments;
     }
-    get name() {
-        return this.resource
-            .value(sh.name)
-            .chain((value) => value.toLiteral())
-            .toMaybe();
+    get identifier() {
+        return this.generatedShaclCoreShape.identifier;
+    }
+    get isDefinedBy() {
+        if (this.generatedShaclCoreShape.isDefinedBy.isJust()) {
+            // If there's an rdfs:isDefinedBy statement on the shape then don't fall back to anything else
+            return this.shapesGraph.ontologyByIdentifier(this.generatedShaclCoreShape.isDefinedBy.unsafeCoerce());
+        }
+        // No rdfs:isDefinedBy statement on the shape
+        const ontologies = this.shapesGraph.ontologies;
+        if (ontologies.length === 1) {
+            // If there's a single ontology in the shapes graph, consider the shape a part of the ontology
+            return Maybe.of(ontologies[0]);
+        }
+        if (this.identifier.termType === "NamedNode") {
+            const prefixOntologies = ontologies.filter((ontology) => ontology.identifier.termType === "NamedNode" &&
+                this.identifier.value.startsWith(ontology.identifier.value));
+            if (prefixOntologies.length === 1) {
+                // If there's a single ontology whose IRI is a prefix of this shape's IRI, consider the shape a part of the ontology
+                return Maybe.of(prefixOntologies[0]);
+            }
+        }
+        return Maybe.empty();
+    }
+    get labels() {
+        return this.generatedShaclCoreShape.labels;
     }
 }
 (function (Shape) {
     class Constraints {
-        constructor(resource, shapesGraph) {
-            this.resource = resource;
+        constructor(generatedShaclCoreShape, shapesGraph) {
+            this.generatedShaclCoreShape = generatedShaclCoreShape;
             this.shapesGraph = shapesGraph;
         }
         get and() {
-            return this.listTakingLogicalConstraint(sh.and);
+            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.and);
         }
         get classes() {
-            return [...this.resource.values(sh.class)].flatMap((value) => value.toIri().toMaybe().toList());
+            return this.generatedShaclCoreShape.classes;
         }
         get datatype() {
-            return this.resource
-                .value(sh.datatype)
-                .chain((value) => value.toIri())
-                .toMaybe();
+            return this.generatedShaclCoreShape.datatype;
         }
-        get hasValue() {
-            return this.resource
-                .value(sh.hasValue)
-                .map((value) => value.toTerm())
-                .toMaybe();
+        get hasValues() {
+            return this.generatedShaclCoreShape.hasValues;
         }
         get in_() {
-            return this.resource
-                .value(sh.in)
-                .chain((value) => value.toList())
-                .map((values) => values.map((value) => value.toTerm()))
-                .toMaybe();
+            return this.generatedShaclCoreShape.in_.orDefault([]);
+        }
+        get languageIn() {
+            return this.generatedShaclCoreShape.languageIn.orDefault([]);
         }
         get maxCount() {
-            return this.resource
-                .value(sh.maxCount)
-                .chain((value) => value.toNumber())
-                .toMaybe();
+            return this.generatedShaclCoreShape.maxCount;
         }
         get maxExclusive() {
-            return this.resource
-                .value(sh.maxExclusive)
-                .chain((value) => value.toLiteral())
-                .toMaybe();
+            return this.generatedShaclCoreShape.maxExclusive;
         }
         get maxInclusive() {
-            return this.resource
-                .value(sh.maxInclusive)
-                .chain((value) => value.toLiteral())
-                .toMaybe();
+            return this.generatedShaclCoreShape.maxInclusive;
         }
         get minCount() {
-            return this.resource
-                .value(sh.minCount)
-                .chain((value) => value.toNumber())
-                .toMaybe();
+            return this.generatedShaclCoreShape.minCount;
         }
         get minExclusive() {
-            return this.resource
-                .value(sh.minExclusive)
-                .chain((value) => value.toLiteral())
-                .toMaybe();
+            return this.generatedShaclCoreShape.minExclusive;
         }
         get minInclusive() {
-            return this.resource
-                .value(sh.minInclusive)
-                .chain((value) => value.toLiteral())
-                .toMaybe();
+            return this.generatedShaclCoreShape.minInclusive;
         }
         get nodeKinds() {
-            const nodeKinds = new Set();
-            for (const nodeKindValue of this.resource.values(sh.nodeKind)) {
-                nodeKindValue.toIri().ifRight((nodeKindIri) => {
-                    if (nodeKindIri.equals(sh.BlankNode)) {
-                        nodeKinds.add(NodeKind.BLANK_NODE);
-                    }
-                    else if (nodeKindIri.equals(sh.BlankNodeOrIRI)) {
-                        nodeKinds.add(NodeKind.BLANK_NODE);
-                        nodeKinds.add(NodeKind.IRI);
-                    }
-                    else if (nodeKindIri.equals(sh.BlankNodeOrLiteral)) {
-                        nodeKinds.add(NodeKind.BLANK_NODE);
-                        nodeKinds.add(NodeKind.LITERAL);
-                    }
-                    else if (nodeKindIri.equals(sh.IRI)) {
-                        nodeKinds.add(NodeKind.IRI);
-                    }
-                    else if (nodeKindIri.equals(sh.IRIOrLiteral)) {
-                        nodeKinds.add(NodeKind.IRI);
-                        nodeKinds.add(NodeKind.LITERAL);
-                    }
-                    else if (nodeKindIri.equals(sh.Literal)) {
-                        nodeKinds.add(NodeKind.LITERAL);
-                    }
-                });
-            }
-            return nodeKinds;
+            return this.generatedShaclCoreShape.nodeKind.chain((iri) => {
+                const nodeKinds = new Set();
+                switch (iri.value) {
+                    case "http://www.w3.org/ns/shacl#BlankNode":
+                        nodeKinds.add("BlankNode");
+                        break;
+                    case "http://www.w3.org/ns/shacl#BlankNodeOrIRI":
+                        nodeKinds.add("BlankNode");
+                        nodeKinds.add("NamedNode");
+                        break;
+                    case "http://www.w3.org/ns/shacl#BlankNodeOrLiteral":
+                        nodeKinds.add("BlankNode");
+                        nodeKinds.add("Literal");
+                        break;
+                    case "http://www.w3.org/ns/shacl#IRI":
+                        nodeKinds.add("NamedNode");
+                        break;
+                    case "http://www.w3.org/ns/shacl#IRIOrLiteral":
+                        nodeKinds.add("Literal");
+                        nodeKinds.add("NamedNode");
+                        break;
+                    case "http://www.w3.org/ns/shacl#Literal":
+                        nodeKinds.add("Literal");
+                        break;
+                }
+                return nodeKinds.size > 0 ? Maybe.of(nodeKinds) : Maybe.empty();
+            });
         }
         get nodes() {
-            return [...this.resource.values(sh.node)].flatMap((value) => value
-                .toIdentifier()
-                .toMaybe()
-                .chain((shapeNode) => this.shapesGraph.nodeShapeByNode(shapeNode))
-                .toList());
+            return this.generatedShaclCoreShape.nodes.flatMap((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier).toList());
         }
         get not() {
-            return [...this.resource.values(sh.not)].flatMap((value) => value
-                .toIdentifier()
-                .toMaybe()
-                .chain((shapeNode) => this.shapesGraph.shapeByNode(shapeNode))
-                .toList());
+            return this.generatedShaclCoreShape.not.flatMap((identifier) => this.shapesGraph.shapeByIdentifier(identifier).toList());
         }
         get or() {
-            return this.listTakingLogicalConstraint(sh.or);
+            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.or);
         }
         get xone() {
-            return this.listTakingLogicalConstraint(sh.xone);
-        }
-        listTakingLogicalConstraint(predicate) {
-            return this.resource
-                .value(predicate)
-                .chain((value) => value.toList())
-                .map((values) => values.flatMap((value) => value
-                .toIdentifier()
-                .toMaybe()
-                .chain((shapeNode) => this.shapesGraph.shapeByNode(shapeNode))
-                .toList()))
-                .orDefault([]);
+            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.xone);
         }
-    }
-    Shape.Constraints = Constraints;
-    class Targets {
-        constructor(resource) {
-            this.resource = resource;
-        }
-        get targetClasses() {
-            return [...this.resource.values(sh.targetClass)].flatMap((value) => value.toIri().toMaybe().toList());
-        }
-        get targetNodes() {
-            return [...this.resource.values(sh.targetNode)].flatMap((value) => value.toLiteral().toMaybe()
-                .altLazy(() => value.toIri().toMaybe())
-                .toList());
-        }
-        get targetObjectsOf() {
-            return [...this.resource.values(sh.targetObjectsOf)].flatMap((value) => value.toIri().toMaybe().toList());
-        }
-        get targetSubjectsOf() {
-            return [...this.resource.values(sh.targetSubjectsOf)].flatMap((value) => value.toIri().toMaybe().toList());
+        shapeListTakingConstraint(identifiers) {
+            return identifiers.flatMap((identifiers) => identifiers.flatMap((identifier) => this.shapesGraph.shapeByIdentifier(identifier).toList()));
         }
     }
-    Shape.Targets = Targets;
+    Shape.Constraints = Constraints;
 })(Shape || (Shape = {}));
 //# sourceMappingURL=Shape.js.map

package/ShapesGraph.d.ts

@@ -1,26 +1,12 @@
-import type { BlankNode, DatasetCore, DefaultGraph, NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { NodeShape } from "./NodeShape.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-import type { Shape } from "./Shape.js";
-export declare class ShapesGraph {
-    readonly dataset: DatasetCore;
-    readonly node: BlankNode | DefaultGraph | NamedNode | null;
-    readonly nodeShapes: readonly NodeShape[];
-    readonly propertyGroups: readonly PropertyGroup[];
-    readonly propertyShapes: readonly PropertyShape[];
-    private readonly nodeShapesByNode;
-    private readonly propertyGroupsByNode;
-    private readonly propertyShapesByNode;
-    private constructor();
-    static fromDataset(dataset: DatasetCore): ShapesGraph;
-    nodeShapeByNode(nodeShapeNode: BlankNode | NamedNode): Maybe<NodeShape>;
-    propertyGroupByNode(propertyGroupNode: NamedNode): Maybe<PropertyGroup>;
-    propertyShapeByNode(propertyShapeNode: BlankNode | NamedNode): Maybe<PropertyShape>;
-    shapeByNode(node: BlankNode | NamedNode): Maybe<Shape>;
-    private readGraph;
-    private readPropertyGroups;
-    private readShapes;
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { OntologyLike } from "./OntologyLike.js";
+export interface ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    readonly ontologies: readonly OntologyT[];
+    nodeShapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<NodeShapeT>;
+    ontologyByIdentifier(identifier: BlankNode | NamedNode): Maybe<OntologyT>;
+    propertyGroupByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyGroupT>;
+    propertyShapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyShapeT>;
+    shapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<ShapeT>;
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map