@shaclmate/shacl-ast 4.0.50 → 4.0.51

package/dist/AbstractShapesGraph.d.ts

@@ -0,0 +1,75 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import TermMap from "@rdfjs/term-map";
+import type { BlankNode, DatasetCore, NamedNode } from "@rdfjs/types";
+import { type Resource, ResourceSet } from "@rdfx/resource";
+import { Either } from "purify-ts";
+import type * as generated from "./shacl-ast.shaclmate.js";
+export declare abstract class AbstractShapesGraph<NodeShapeT extends generated.NodeShape, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends generated.PropertyShape> {
+    private readonly nodeShapesByIdentifier;
+    private readonly ontologiesByIdentifier;
+    private readonly propertyGroupsByIdentifier;
+    private readonly propertyShapesByIdentifier;
+    protected abstract readonly typeFunctions: {
+        NodeShape: TypeFunctions<NodeShapeT>;
+        Ontology: TypeFunctions<OntologyT>;
+        PropertyGroup: TypeFunctions<PropertyGroupT>;
+        PropertyShape: TypeFunctions<PropertyShapeT>;
+    };
+    constructor(parameters: {
+        nodeShapesByIdentifier: IdentifierMap<NodeShapeT>;
+        ontologiesByIdentifier: IdentifierMap<OntologyT>;
+        propertyGroupsByIdentifier: IdentifierMap<PropertyGroupT>;
+        propertyShapesByIdentifier: IdentifierMap<PropertyShapeT>;
+    });
+    get nodeShapes(): readonly NodeShapeT[];
+    get ontologies(): readonly OntologyT[];
+    get propertyGroups(): readonly PropertyGroupT[];
+    get propertyShapes(): readonly PropertyShapeT[];
+    nodeShape(identifier: BlankNode | NamedNode): Either<Error, NodeShapeT>;
+    ontology(identifier: BlankNode | NamedNode): Either<Error, OntologyT>;
+    propertyGroup(identifier: BlankNode | NamedNode): Either<Error, PropertyGroupT>;
+    propertyShape(identifier: BlankNode | NamedNode): Either<Error, PropertyShapeT>;
+    shape(identifier: BlankNode | NamedNode): Either<Error, NodeShapeT | PropertyShapeT>;
+    /**
+     * Convert the shapes graph to a dataset.
+     */
+    toDataset(): DatasetCore;
+    /**
+     * Convert the shapes graph to an RDF string.
+     *
+     * If the format isn't specified, defaults to N-Triples.
+     */
+    toString(options?: {
+        format?: "application/n-triples" | "application/n-quads";
+    }): string;
+}
+type IdentifierMap<T> = TermMap<BlankNode | NamedNode, T>;
+type TypeFunctions<T> = {
+    fromRdfResource: (resource: Resource, options?: {
+        ignoreRdfType?: boolean;
+    }) => Either<Error, T>;
+    toRdfResource: (value: T, options?: {
+        resourceSet?: ResourceSet;
+    }) => Resource;
+};
+export declare namespace AbstractShapesGraph {
+    abstract class AbstractBuilder<NodeShapeT extends generated.NodeShape, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends generated.PropertyShape> {
+        protected readonly nodeShapesByIdentifier: IdentifierMap<NodeShapeT>;
+        protected readonly ontologiesByIdentifier: IdentifierMap<OntologyT>;
+        protected readonly propertyGroupsByIdentifier: IdentifierMap<PropertyGroupT>;
+        protected readonly propertyShapesByIdentifier: IdentifierMap<PropertyShapeT>;
+        protected abstract readonly typeFunctions: {
+            NodeShape: TypeFunctions<NodeShapeT>;
+            Ontology: TypeFunctions<OntologyT>;
+            PropertyGroup: TypeFunctions<PropertyGroupT>;
+            PropertyShape: TypeFunctions<PropertyShapeT>;
+        };
+        add(...objects: readonly (NodeShapeT | OntologyT | PropertyGroupT | PropertyShapeT)[]): this;
+        parseDataset(dataset: DatasetCore, options?: {
+            ignoreUndefinedShapes?: boolean;
+            prefixMap?: PrefixMap;
+        }): Either<Error, this>;
+    }
+}
+export {};
+//# sourceMappingURL=AbstractShapesGraph.d.ts.map

package/dist/AbstractShapesGraph.js

@@ -0,0 +1,364 @@
+import datasetFactory from "@rdfjs/dataset";
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import dataFactory from "@rdfx/data-factory";
+import { ResourceSet } from "@rdfx/resource";
+import { NTriplesTerm } from "@rdfx/string";
+import { owl, sh } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { CurieFactory } from "./CurieFactory.js";
+export class AbstractShapesGraph {
+    nodeShapesByIdentifier;
+    ontologiesByIdentifier;
+    propertyGroupsByIdentifier;
+    propertyShapesByIdentifier;
+    constructor(parameters) {
+        // Defensive copies
+        this.nodeShapesByIdentifier = new TermMap([
+            ...parameters.nodeShapesByIdentifier.entries(),
+        ]);
+        this.ontologiesByIdentifier = new TermMap([
+            ...parameters.ontologiesByIdentifier.entries(),
+        ]);
+        this.propertyGroupsByIdentifier = new TermMap([
+            ...parameters.propertyGroupsByIdentifier.entries(),
+        ]);
+        this.propertyShapesByIdentifier = new TermMap([
+            ...parameters.propertyShapesByIdentifier.entries(),
+        ]);
+    }
+    get nodeShapes() {
+        return [...this.nodeShapesByIdentifier.values()];
+    }
+    get ontologies() {
+        return [...this.ontologiesByIdentifier.values()];
+    }
+    get propertyGroups() {
+        return [...this.propertyGroupsByIdentifier.values()];
+    }
+    get propertyShapes() {
+        return [...this.propertyShapesByIdentifier.values()];
+    }
+    nodeShape(identifier) {
+        const nodeShape = this.nodeShapesByIdentifier.get(identifier);
+        return nodeShape
+            ? Either.of(nodeShape)
+            : Left(new Error(`no such node shape ${identifier}`));
+    }
+    ontology(identifier) {
+        const ontology = this.ontologiesByIdentifier.get(identifier);
+        return ontology
+            ? Either.of(ontology)
+            : Left(new Error(`no such ontology ${identifier}`));
+    }
+    propertyGroup(identifier) {
+        const propertyGroup = this.propertyGroupsByIdentifier.get(identifier);
+        return propertyGroup
+            ? Either.of(propertyGroup)
+            : Left(new Error(`no such property group ${identifier}`));
+    }
+    propertyShape(identifier) {
+        const propertyShape = this.propertyShapesByIdentifier.get(identifier);
+        return propertyShape
+            ? Either.of(propertyShape)
+            : Left(new Error(`no such property shape ${identifier}`));
+    }
+    shape(identifier) {
+        return this.nodeShape(identifier)
+            .alt(this.propertyShape(identifier))
+            .mapLeft(() => new Error(`no such shape ${identifier}`));
+    }
+    /**
+     * Convert the shapes graph to a dataset.
+     */
+    toDataset() {
+        const dataset = datasetFactory.dataset();
+        const resourceSet = new ResourceSet({ dataFactory, dataset });
+        for (const nodeShape of this.nodeShapes) {
+            this.typeFunctions.NodeShape.toRdfResource(nodeShape, { resourceSet });
+        }
+        for (const ontology of this.ontologies) {
+            this.typeFunctions.Ontology.toRdfResource(ontology, { resourceSet });
+        }
+        for (const propertyGroup of this.propertyGroups) {
+            this.typeFunctions.PropertyGroup.toRdfResource(propertyGroup, {
+                resourceSet,
+            });
+        }
+        for (const propertyShape of this.propertyShapes) {
+            this.typeFunctions.PropertyShape.toRdfResource(propertyShape, {
+                resourceSet,
+            });
+        }
+        return dataset;
+    }
+    /**
+     * Convert the shapes graph to an RDF string.
+     *
+     * If the format isn't specified, defaults to N-Triples.
+     */
+    toString(options) {
+        const format = options?.format ?? "application/n-triples";
+        const lines = [];
+        switch (format) {
+            case "application/n-quads": {
+                for (const quad of this.toDataset()) {
+                    const graphString = quad.graph.termType === "DefaultGraph"
+                        ? ""
+                        : ` ${NTriplesTerm.stringify(quad.graph)}`;
+                    lines.push(`${NTriplesTerm.stringify(quad.subject)} ${NTriplesTerm.stringify(quad.predicate)} ${NTriplesTerm.stringify(quad.object)}${graphString} .\n`);
+                }
+                break;
+            }
+            case "application/n-triples":
+                {
+                    for (const quad of this.toDataset()) {
+                        lines.push(`${NTriplesTerm.stringify(quad.subject)} ${NTriplesTerm.stringify(quad.predicate)} ${NTriplesTerm.stringify(quad.object)} .\n`);
+                    }
+                }
+                break;
+        }
+        return lines.join("");
+    }
+}
+(function (AbstractShapesGraph) {
+    class AbstractBuilder {
+        nodeShapesByIdentifier = new TermMap();
+        ontologiesByIdentifier = new TermMap();
+        propertyGroupsByIdentifier = new TermMap();
+        propertyShapesByIdentifier = new TermMap();
+        add(...objects) {
+            for (const object of objects) {
+                switch (object.$type) {
+                    case "NodeShape":
+                        this.nodeShapesByIdentifier.set(object.$identifier(), object);
+                        break;
+                    case "Ontology":
+                        this.ontologiesByIdentifier.set(object.$identifier(), object);
+                        break;
+                    case "PropertyGroup":
+                        this.propertyGroupsByIdentifier.set(object.$identifier(), object);
+                        break;
+                    case "PropertyShape":
+                        this.propertyShapesByIdentifier.set(object.$identifier(), object);
+                        break;
+                }
+            }
+            return this;
+        }
+        parseDataset(dataset, options) {
+            function datasetHasMatch(subject, predicate, object, graph) {
+                for (const _ of dataset.match(subject, predicate, object, graph)) {
+                    return true;
+                }
+                return false;
+            }
+            let curieDataset;
+            if (options?.prefixMap) {
+                const curieCache = new Map();
+                curieDataset = datasetFactory.dataset();
+                const curieFactory = new CurieFactory({
+                    prefixMap: options.prefixMap,
+                });
+                const termToCurie = (term) => {
+                    if (term.termType !== "NamedNode") {
+                        return term;
+                    }
+                    const cachedCurie = curieCache.get(term.value);
+                    if (cachedCurie) {
+                        return cachedCurie;
+                    }
+                    const curie = curieFactory.create(term).extract() ?? term;
+                    curieCache.set(term.value, curie);
+                    return curie;
+                };
+                for (const quad of dataset) {
+                    const curieObject = termToCurie(quad.object);
+                    const curieSubject = termToCurie(quad.subject);
+                    if (!Object.is(curieObject, quad.object) ||
+                        !Object.is(curieSubject, quad.subject)) {
+                        curieDataset.add(dataFactory.quad(curieSubject, quad.predicate, curieObject, quad.graph));
+                    }
+                    else {
+                        curieDataset.add(quad);
+                    }
+                }
+            }
+            else {
+                curieDataset = dataset;
+            }
+            const curieResourceSet = new ResourceSet({
+                dataFactory,
+                dataset: curieDataset,
+            });
+            return Either.encase(() => {
+                function readGraph() {
+                    const graphs = new TermSet();
+                    for (const quad of dataset) {
+                        graphs.add(quad.graph);
+                    }
+                    if (graphs.size !== 1) {
+                        return undefined;
+                    }
+                    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}`);
+                    }
+                }
+                const graph = readGraph();
+                // Read ontologies
+                for (const ontologyResource of curieResourceSet.instancesOf(owl.Ontology, {
+                    graph,
+                })) {
+                    if (this.ontologiesByIdentifier.has(ontologyResource.identifier)) {
+                        continue;
+                    }
+                    this.typeFunctions.Ontology.fromRdfResource(ontologyResource, {
+                        ignoreRdfType: true,
+                    }).ifRight((ontology) => this.add(ontology));
+                }
+                // Read property groups
+                for (const propertyGroupResource of curieResourceSet.instancesOf(sh.PropertyGroup, { graph })) {
+                    if (propertyGroupResource.identifier.termType !== "NamedNode") {
+                        continue;
+                    }
+                    if (this.propertyGroupsByIdentifier.has(propertyGroupResource.identifier)) {
+                        continue;
+                    }
+                    this.typeFunctions.PropertyGroup.fromRdfResource(curieResourceSet.resource(propertyGroupResource.identifier), { ignoreRdfType: true }).ifRight((propertyGroup) => this.add(propertyGroup));
+                }
+                // Read shapes
+                // Collect the shape identifiers in sets
+                const shapeNodeSet = new TermSet();
+                // Utility function for adding to the shapeNodeSet
+                function addShapeNode(shapeNode) {
+                    switch (shapeNode.termType) {
+                        case "BlankNode":
+                        case "NamedNode":
+                            shapeNodeSet.add(shapeNode);
+                            return true;
+                        default:
+                            throw new RangeError(`unexpected shape node identifier term type: ${shapeNode.termType}`);
+                    }
+                }
+                // 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 curieResourceSet.instancesOf(rdfType, {
+                        graph,
+                    })) {
+                        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 dataset.match(null, predicate, null, graph)) {
+                        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 dataset.match(null, predicate, null, graph)) {
+                        addShapeNode(quad.subject);
+                    }
+                }
+                // Object of a shape-expecting, non-list-taking parameter such as sh:node
+                for (const predicate of [sh.node, sh.not, sh.property]) {
+                    for (const quad of dataset.match(null, predicate, null, graph)) {
+                        addShapeNode(quad.object);
+                        if (!options?.ignoreUndefinedShapes &&
+                            !datasetHasMatch(quad.object)) {
+                            throw new Error(`undefined shape: ${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 dataset.match(null, predicate, null, graph)) {
+                        switch (quad.object.termType) {
+                            case "BlankNode":
+                            case "NamedNode":
+                                break;
+                            default:
+                                throw new RangeError(`expected list term to be a blank or named node, not ${quad.object.termType}`);
+                        }
+                        for (const value of curieResourceSet
+                            .resource(quad.object)
+                            .toList()
+                            .unsafeCoerce()) {
+                            const identifier = value.toIdentifier().unsafeCoerce();
+                            addShapeNode(identifier);
+                            if (!options?.ignoreUndefinedShapes &&
+                                !datasetHasMatch(identifier)) {
+                                throw new Error(`undefined shape: ${identifier}`);
+                            }
+                        }
+                    }
+                }
+                // Separate shapes into node and property shapes.
+                for (const shapeNode of shapeNodeSet) {
+                    if (dataset.match(shapeNode, sh.path, null, graph).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.
+                        this.add(this.typeFunctions.PropertyShape.fromRdfResource(curieResourceSet.resource(shapeNode), {
+                            ignoreRdfType: true,
+                        }).unsafeCoerce());
+                    }
+                    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.
+                        this.add(this.typeFunctions.NodeShape.fromRdfResource(curieResourceSet.resource(shapeNode), {
+                            ignoreRdfType: true,
+                        }).unsafeCoerce());
+                    }
+                }
+                return this;
+            });
+        }
+    }
+    AbstractShapesGraph.AbstractBuilder = AbstractBuilder;
+})(AbstractShapesGraph || (AbstractShapesGraph = {}));
+//# sourceMappingURL=AbstractShapesGraph.js.map

package/dist/Curie.d.ts

@@ -0,0 +1,21 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export declare class Curie implements NamedNode {
+    #private;
+    readonly prefix: string;
+    readonly reference: string;
+    readonly termType = "NamedNode";
+    readonly value: string;
+    constructor({ hasUniqueReference, prefix, reference, value, }: {
+        hasUniqueReference?: () => boolean;
+        prefix: string;
+        reference: string;
+        value: string;
+    });
+    equals(other: BlankNode | NamedNode): boolean;
+    get hasUniqueReference(): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=Curie.d.ts.map

package/dist/Curie.js

@@ -0,0 +1,29 @@
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export class Curie {
+    prefix;
+    #hasUniqueReference;
+    reference;
+    termType = "NamedNode";
+    value;
+    constructor({ hasUniqueReference, prefix, reference, value, }) {
+        this.#hasUniqueReference = hasUniqueReference ?? (() => false);
+        this.prefix = prefix;
+        this.reference = reference;
+        this.value = value;
+    }
+    equals(other) {
+        if (other.termType === "BlankNode") {
+            return false;
+        }
+        return this.value === other.value; // Allow a Curie to equal a NamedNode
+    }
+    get hasUniqueReference() {
+        return this.#hasUniqueReference();
+    }
+    toString() {
+        return `${this.prefix}:${this.reference}`;
+    }
+}
+//# sourceMappingURL=Curie.js.map

package/dist/CurieFactory.d.ts

@@ -0,0 +1,16 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export declare class CurieFactory {
+    private readonly prefixMap;
+    private readonly referenceCounts;
+    constructor({ prefixMap }: {
+        prefixMap: PrefixMap;
+    });
+    create(namedNode: NamedNode): Maybe<Curie>;
+}
+//# sourceMappingURL=CurieFactory.d.ts.map

package/dist/CurieFactory.js

@@ -0,0 +1,46 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export class CurieFactory {
+    prefixMap;
+    referenceCounts = {};
+    constructor({ prefixMap }) {
+        this.prefixMap = prefixMap;
+    }
+    create(namedNode) {
+        return Maybe.fromNullable(this.prefixMap.shrink(namedNode)?.value).map((value) => {
+            const split = value.split(":", 2);
+            invariant(split.length === 2);
+            const prefix = split[0];
+            const reference = split[1];
+            if (this.referenceCounts[reference] === undefined) {
+                this.referenceCounts[reference] = {};
+            }
+            if (this.referenceCounts[reference][prefix] === undefined) {
+                this.referenceCounts[reference][prefix] = 1;
+            }
+            else {
+                this.referenceCounts[reference][prefix] += 1;
+            }
+            return new Curie({
+                hasUniqueReference: () => {
+                    const referenceCounts = this.referenceCounts[reference];
+                    if (Object.entries(referenceCounts).length === 1) {
+                        return true;
+                    }
+                    // logger.debug(
+                    //   `duplicate local part ${reference} in ${JSON.stringify(referenceCounts)}`,
+                    // );
+                    return false;
+                },
+                prefix: split[0],
+                reference: split[1],
+                value: namedNode.value,
+            });
+        });
+    }
+}
+//# sourceMappingURL=CurieFactory.js.map

package/dist/IdentifierNodeKind.d.ts

@@ -0,0 +1,6 @@
+import type { NodeKind } from "./NodeKind.js";
+/**
+ * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
+ */
+export type IdentifierNodeKind = Exclude<NodeKind, "Literal">;
+//# sourceMappingURL=IdentifierNodeKind.d.ts.map

package/dist/IdentifierNodeKind.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IdentifierNodeKind.js.map

package/dist/NodeKind.d.ts

@@ -0,0 +1,11 @@
+import type { NamedNode } from "@rdfjs/types";
+/**
+ * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
+ */
+export type NodeKind = "BlankNode" | "IRI" | "Literal";
+export declare namespace NodeKind {
+    function fromIri(iri: NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">): ReadonlySet<NodeKind>;
+    function fromTermType(termType: "BlankNode" | "Literal" | "NamedNode"): NodeKind;
+    function toTermType(nodeKind: NodeKind): "BlankNode" | "Literal" | "NamedNode";
+}
+//# sourceMappingURL=NodeKind.d.ts.map

package/dist/NodeKind.js

@@ -0,0 +1,43 @@
+export var NodeKind;
+(function (NodeKind) {
+    function fromIri(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("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("IRI");
+                break;
+            case "http://www.w3.org/ns/shacl#IRIOrLiteral":
+                nodeKinds.add("IRI");
+                nodeKinds.add("Literal");
+                break;
+            case "http://www.w3.org/ns/shacl#Literal":
+                nodeKinds.add("Literal");
+                break;
+            default:
+                iri.value;
+                throw new RangeError(iri.value);
+        }
+        return nodeKinds;
+    }
+    NodeKind.fromIri = fromIri;
+    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/ShapesGraph.d.ts

@@ -0,0 +1,27 @@
+import { AbstractShapesGraph } from "./AbstractShapesGraph.js";
+import * as generated from "./shacl-ast.shaclmate.js";
+export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+    protected readonly typeFunctions: {
+        readonly NodeShape: typeof generated.NodeShape;
+        readonly Ontology: typeof generated.Ontology;
+        readonly PropertyGroup: typeof generated.PropertyGroup;
+        readonly PropertyShape: typeof generated.PropertyShape;
+    };
+    static builder(): ShapesGraph.Builder;
+}
+export declare namespace ShapesGraph {
+    class Builder extends AbstractShapesGraph.AbstractBuilder<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+        protected readonly typeFunctions: {
+            readonly NodeShape: typeof generated.NodeShape;
+            readonly Ontology: typeof generated.Ontology;
+            readonly PropertyGroup: typeof generated.PropertyGroup;
+            readonly PropertyShape: typeof generated.PropertyShape;
+        };
+        build(): ShapesGraph;
+        nodeShape(parameters?: Parameters<typeof generated.NodeShape.createUnsafe>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.createUnsafe>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.create>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.createUnsafe>[0]): generated.PropertyShape;
+    }
+}
+//# sourceMappingURL=ShapesGraph.d.ts.map