@shaclmate/shacl-ast 3.0.4 → 4.0.1

package/README.md

@@ -11,7 +11,7 @@ Build an Abstract Syntax Tree (AST) of [Shapes Constraint Language (SHACL)](http
 ```ts
 import { ShapesGraph } from "@shaclmate/shacl-ast";
 
-const shapesGraph = ShapesGraph.fromDataset(testShapesGraph);
+const shapesGraph = ShapesGraph.Factory.default_.createShapesGraph(testShapesGraphDataset);
 for (const nodeShape of shapesGraph.nodeShapes) {
   console.info("Node shape: ", nodeShape.node.value);
   for (const propertyShape of shapesGraph.propertyShapes) {

package/dist/IdentifierNodeKind.d.ts

@@ -1,6 +1,6 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "./NodeKind.js";
 /**
  * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
  */
-export type IdentifierNodeKind = (BlankNode | NamedNode)["termType"];
+export type IdentifierNodeKind = Exclude<NodeKind, "Literal">;
 //# sourceMappingURL=IdentifierNodeKind.d.ts.map

package/dist/NodeKind.d.ts

@@ -1,6 +1,9 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 /**
  * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
  */
-export type NodeKind = (BlankNode | NamedNode | Literal)["termType"];
+export type NodeKind = "BlankNode" | "IRI" | "Literal";
+export declare namespace NodeKind {
+    function fromTermType(termType: "BlankNode" | "Literal" | "NamedNode"): NodeKind;
+    function toTermType(nodeKind: NodeKind): "BlankNode" | "Literal" | "NamedNode";
+}
 //# sourceMappingURL=NodeKind.d.ts.map

package/dist/NodeKind.js

@@ -1,2 +1,12 @@
-export {};
+export var NodeKind;
+(function (NodeKind) {
+    function fromTermType(termType) {
+        return termType === "NamedNode" ? "IRI" : termType;
+    }
+    NodeKind.fromTermType = fromTermType;
+    function toTermType(nodeKind) {
+        return nodeKind === "IRI" ? "NamedNode" : nodeKind;
+    }
+    NodeKind.toTermType = toTermType;
+})(NodeKind || (NodeKind = {}));
 //# sourceMappingURL=NodeKind.js.map

package/dist/NodeShape.d.ts

@@ -1,8 +1,8 @@
-import type { Maybe } from "purify-ts";
+import { Either, type Maybe } from "purify-ts";
+import type * as generated from "./generated.js";
 import type { OntologyLike } from "./OntologyLike.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-import type * as generated from "./generated.js";
 export declare class NodeShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
     readonly constraints: NodeShape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
     constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
@@ -13,7 +13,7 @@ export declare namespace NodeShape {
         private readonly generatedShaclCoreNodeShape;
         constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get closed(): Maybe<boolean>;
-        get properties(): readonly PropertyShapeT[];
+        get properties(): Either<Error, readonly PropertyShapeT[]>;
     }
 }
 //# sourceMappingURL=NodeShape.d.ts.map

package/dist/NodeShape.js

@@ -1,3 +1,12 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Either } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class NodeShape extends Shape {
     constraints;
@@ -6,9 +15,12 @@ export class NodeShape extends Shape {
         this.constraints = new NodeShape.Constraints(generatedShaclCoreNodeShape, shapesGraph);
     }
     toString() {
-        return `NodeShape(node=${this.identifier.value})`;
+        return `NodeShape(identifier=${Resource.Identifier.toString(this.identifier)})`;
     }
 }
+__decorate([
+    Memoize()
+], NodeShape.prototype, "toString", null);
 (function (NodeShape) {
     class Constraints extends Shape.Constraints {
         generatedShaclCoreNodeShape;
@@ -20,9 +32,12 @@ export class NodeShape extends Shape {
             return this.generatedShaclCoreNodeShape.closed;
         }
         get properties() {
-            return this.generatedShaclCoreNodeShape.properties.flatMap((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier).toList());
+            return Either.sequence(this.generatedShaclCoreNodeShape.properties.map((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier)));
         }
     }
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "properties", null);
     NodeShape.Constraints = Constraints;
 })(NodeShape || (NodeShape = {}));
 //# sourceMappingURL=NodeShape.js.map

package/dist/Ontology.d.ts

@@ -1,6 +1,6 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { OntologyLike } from "./OntologyLike.js";
 import type * as generated from "./generated.js";
+import type { OntologyLike } from "./OntologyLike.js";
 export declare class Ontology implements OntologyLike {
     private readonly generatedOntology;
     constructor(generatedOntology: Omit<generated.OwlOntology, "$type">);

package/dist/Ontology.js

@@ -1,3 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Resource } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
 export class Ontology {
     generatedOntology;
     constructor(generatedOntology) {
@@ -7,7 +15,10 @@ export class Ontology {
         return this.generatedOntology.$identifier;
     }
     toString() {
-        return `Ontology(node=${this.identifier.value})`;
+        return `Ontology(identifier=${Resource.Identifier.toString(this.identifier)})`;
     }
 }
+__decorate([
+    Memoize()
+], Ontology.prototype, "toString", null);
 //# sourceMappingURL=Ontology.js.map

package/dist/PropertyGroup.d.ts

@@ -1,10 +1,11 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type * as generated from "./generated.js";
 export declare class PropertyGroup {
     private readonly delegate;
     constructor(delegate: generated.ShaclCorePropertyGroup);
-    get comments(): readonly Literal[];
+    get comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
-    get labels(): readonly Literal[];
+    get labels(): readonly string[];
+    toString(): string;
 }
 //# sourceMappingURL=PropertyGroup.d.ts.map

package/dist/PropertyGroup.js

@@ -1,3 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Resource } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
 export class PropertyGroup {
     delegate;
     constructor(delegate) {
@@ -12,5 +20,11 @@ export class PropertyGroup {
     get labels() {
         return this.delegate.labels;
     }
+    toString() {
+        return `PropertyGroup(identifier=${Resource.Identifier.toString(this.identifier)})`;
+    }
 }
+__decorate([
+    Memoize()
+], PropertyGroup.prototype, "toString", null);
 //# sourceMappingURL=PropertyGroup.js.map

package/dist/PropertyShape.d.ts

@@ -1,18 +1,18 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
+import { Either, type Maybe } from "purify-ts";
+import { PropertyPath } from "rdfjs-resource";
+import type * as generated from "./generated.js";
 import type { OntologyLike } from "./OntologyLike.js";
-import type { PropertyPath } from "./PropertyPath.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-import type * as generated from "./generated.js";
 export declare class PropertyShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
     private readonly generatedShaclCorePropertyShape;
     readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
     constructor(generatedShaclCorePropertyShape: Omit<generated.ShaclCorePropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get defaultValue(): Maybe<Literal | NamedNode>;
-    get descriptions(): readonly Literal[];
-    get groups(): readonly PropertyGroupT[];
-    get names(): readonly Literal[];
+    get descriptions(): readonly string[];
+    get groups(): Either<Error, readonly PropertyGroupT[]>;
+    get names(): readonly string[];
     get order(): Maybe<number>;
     get path(): PropertyPath;
     toString(): string;

package/dist/PropertyShape.js

@@ -1,3 +1,12 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Either } from "purify-ts";
+import { PropertyPath, Resource } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class PropertyShape extends Shape {
     generatedShaclCorePropertyShape;
@@ -14,7 +23,7 @@ export class PropertyShape extends Shape {
         return this.generatedShaclCorePropertyShape.descriptions;
     }
     get groups() {
-        return this.generatedShaclCorePropertyShape.groups.flatMap((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier).toList());
+        return Either.sequence(this.generatedShaclCorePropertyShape.groups.map((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier)));
     }
     get names() {
         return this.generatedShaclCorePropertyShape.names;
@@ -26,12 +35,16 @@ export class PropertyShape extends Shape {
         return this.generatedShaclCorePropertyShape.path;
     }
     toString() {
-        const keyValues = [`node=${this.identifier.value}`];
-        const path = this.path;
-        if (path.kind === "PredicatePath") {
-            keyValues.push(`path=${path.iri.value}`);
-        }
-        return `PropertyShape(${keyValues.join(", ")})`;
+        return `PropertyShape(${[
+            `identifier=${Resource.Identifier.toString(this.identifier)}`,
+            `path=${PropertyPath.$toString(this.path)}`,
+        ].join(", ")})`;
     }
 }
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "groups", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "toString", null);
 //# sourceMappingURL=PropertyShape.js.map

package/dist/Shape.d.ts

@@ -1,25 +1,25 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
+import { Either, Maybe } from "purify-ts";
+import type * as generated from "./generated.js";
 import type { NodeKind } from "./NodeKind.js";
 import type { OntologyLike } from "./OntologyLike.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-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 comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
-    get isDefinedBy(): Maybe<OntologyT>;
-    get labels(): readonly Literal[];
+    get isDefinedBy(): Either<Error, Maybe<OntologyT>>;
+    get labels(): readonly string[];
 }
 export declare namespace 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 and(): Either<Error, readonly ShapeT[]>;
         get classes(): readonly NamedNode[];
         get datatype(): Maybe<NamedNode>;
         get hasValues(): readonly (Literal | NamedNode)[];
@@ -31,11 +31,11 @@ export declare namespace Shape {
         get minCount(): Maybe<number>;
         get minExclusive(): Maybe<Literal>;
         get minInclusive(): Maybe<Literal>;
-        get nodeKinds(): Maybe<Set<NodeKind>>;
-        get nodes(): readonly NodeShapeT[];
-        get not(): readonly ShapeT[];
-        get or(): readonly ShapeT[];
-        get xone(): readonly ShapeT[];
+        get nodeKinds(): ReadonlySet<NodeKind>;
+        get nodes(): Either<Error, readonly NodeShapeT[]>;
+        get not(): Either<Error, readonly ShapeT[]>;
+        get or(): Either<Error, readonly ShapeT[]>;
+        get xone(): Either<Error, readonly ShapeT[]>;
         private shapeListTakingConstraint;
     }
 }

package/dist/Shape.js

@@ -1,4 +1,11 @@
-import { Maybe } from "purify-ts";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Either, Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 export class Shape {
     generatedShaclCoreShape;
     shapesGraph;
@@ -15,28 +22,33 @@ export class Shape {
     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());
+            return this.shapesGraph
+                .ontologyByIdentifier(this.generatedShaclCoreShape.isDefinedBy.unsafeCoerce())
+                .map(Maybe.of);
         }
         // 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]);
+            return Either.of(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 Either.of(Maybe.of(prefixOntologies[0]));
             }
         }
-        return Maybe.empty();
+        return Either.of(Maybe.empty());
     }
     get labels() {
         return this.generatedShaclCoreShape.labels;
     }
 }
+__decorate([
+    Memoize()
+], Shape.prototype, "isDefinedBy", null);
 (function (Shape) {
     class Constraints {
         generatedShaclCoreShape;
@@ -82,7 +94,8 @@ export class Shape {
             return this.generatedShaclCoreShape.minInclusive;
         }
         get nodeKinds() {
-            return this.generatedShaclCoreShape.nodeKind.chain((iri) => {
+            return this.generatedShaclCoreShape.nodeKind
+                .map((iri) => {
                 const nodeKinds = new Set();
                 switch (iri.value) {
                     case "http://www.w3.org/ns/shacl#BlankNode":
@@ -90,31 +103,32 @@ export class Shape {
                         break;
                     case "http://www.w3.org/ns/shacl#BlankNodeOrIRI":
                         nodeKinds.add("BlankNode");
-                        nodeKinds.add("NamedNode");
+                        nodeKinds.add("IRI");
                         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");
+                        nodeKinds.add("IRI");
                         break;
                     case "http://www.w3.org/ns/shacl#IRIOrLiteral":
+                        nodeKinds.add("IRI");
                         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();
-            });
+                return nodeKinds;
+            })
+                .orDefault(new Set([]));
         }
         get nodes() {
-            return this.generatedShaclCoreShape.nodes.flatMap((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier).toList());
+            return Either.sequence(this.generatedShaclCoreShape.nodes.map((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier)));
         }
         get not() {
-            return this.generatedShaclCoreShape.not.flatMap((identifier) => this.shapesGraph.shapeByIdentifier(identifier).toList());
+            return Either.sequence(this.generatedShaclCoreShape.not.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier)));
         }
         get or() {
             return this.shapeListTakingConstraint(this.generatedShaclCoreShape.or);
@@ -123,9 +137,27 @@ export class Shape {
             return this.shapeListTakingConstraint(this.generatedShaclCoreShape.xone);
         }
         shapeListTakingConstraint(identifiers) {
-            return identifiers.flatMap((identifiers) => identifiers.flatMap((identifier) => this.shapesGraph.shapeByIdentifier(identifier).toList()));
+            return Either.sequence(identifiers.flatMap((identifiers) => identifiers.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier))));
         }
     }
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "and", null);
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "nodeKinds", null);
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "nodes", null);
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "not", null);
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "or", null);
+    __decorate([
+        Memoize()
+    ], Constraints.prototype, "xone", null);
     Shape.Constraints = Constraints;
 })(Shape || (Shape = {}));
 //# sourceMappingURL=Shape.js.map

package/dist/ShapesGraph.d.ts

@@ -1,12 +1,84 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
+import TermMap from "@rdfjs/term-map";
+import type { BlankNode, DatasetCore, NamedNode } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+import { NodeShape } from "./NodeShape.js";
+import { Ontology } from "./Ontology.js";
 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>;
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+import type { Shape } from "./Shape.js";
+export declare class ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    private readonly nodeShapesByIdentifier;
+    private readonly ontologiesByIdentifier;
+    private readonly propertyGroupsByIdentifier;
+    private readonly propertyShapesByIdentifier;
+    constructor(parameters: {
+        nodeShapesByIdentifier: TermMap<BlankNode | NamedNode, NodeShapeT>;
+        ontologiesByIdentifier: TermMap<BlankNode | NamedNode, OntologyT>;
+        propertyGroupsByIdentifier: TermMap<BlankNode | NamedNode, PropertyGroupT>;
+        propertyShapesByIdentifier: TermMap<BlankNode | NamedNode, PropertyShapeT>;
+    });
+    get nodeShapes(): readonly NodeShapeT[];
+    nodeShapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, NodeShapeT>;
+    get ontologies(): readonly OntologyT[];
+    ontologyByIdentifier(identifier: BlankNode | NamedNode): Either<Error, OntologyT>;
+    propertyGroupByIdentifier(identifier: BlankNode | NamedNode): Either<Error, PropertyGroupT>;
+    get propertyGroups(): readonly PropertyGroupT[];
+    propertyShapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, PropertyShapeT>;
+    get propertyShapes(): readonly PropertyShapeT[];
+    shapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, ShapeT>;
+}
+export declare namespace ShapesGraph {
+    export abstract class Factory<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+        protected preferredLanguages: readonly string[];
+        constructor(parameters?: {
+            preferredLanguages?: readonly string[];
+        });
+        createShapesGraph({ dataset, ignoreUndefinedShapes, }: {
+            dataset: DatasetCore;
+            ignoreUndefinedShapes?: boolean;
+        }): Either<Error, ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>>;
+        protected abstract createNodeShape(parameters: {
+            resource: Resource;
+            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+        }): Either<Error, NodeShapeT>;
+        protected abstract createOntology(parameters: {
+            resource: Resource;
+            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+        }): Either<Error, OntologyT>;
+        protected abstract createPropertyGroup(parameters: {
+            resource: Resource;
+            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+        }): Either<Error, PropertyGroupT>;
+        protected abstract createPropertyShape(parameters: {
+            resource: Resource;
+            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+        }): Either<Error, PropertyShapeT>;
+    }
+    type DefaultNodeShape = NodeShape<any, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
+    type DefaultPropertyShape = PropertyShape<DefaultNodeShape, Ontology, PropertyGroup, any, DefaultShape>;
+    type DefaultShape = Shape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, any>;
+    type DefaultShapesGraph = ShapesGraph<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
+    class DefaultFactory extends Factory<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape> {
+        protected createNodeShape({ resource, shapesGraph, }: {
+            resource: Resource;
+            shapesGraph: DefaultShapesGraph;
+        }): Either<Error, NodeShape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>>;
+        protected createOntology({ resource, }: {
+            resource: Resource;
+            shapesGraph: DefaultShapesGraph;
+        }): Either<Error, Ontology>;
+        protected createPropertyGroup({ resource, }: {
+            resource: Resource;
+            shapesGraph: DefaultShapesGraph;
+        }): Either<Error, PropertyGroup>;
+        protected createPropertyShape({ resource, shapesGraph, }: {
+            resource: Resource;
+            shapesGraph: DefaultShapesGraph;
+        }): Either<Error, DefaultPropertyShape>;
+    }
+    export function create(parameters: Parameters<DefaultFactory["createShapesGraph"]>[0]): Either<Error, DefaultShapesGraph>;
+    export {};
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map