@shaclmate/shacl-ast 4.0.14 → 4.0.16

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 { Resource, ResourceSet } from "@rdfx/resource";
+import { Either } from "purify-ts";
+import type * as generated from "./generated.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,380 @@
+import DataFactory from "@rdfjs/data-model";
+import DatasetFactory from "@rdfjs/dataset";
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { Resource, ResourceSet } from "@rdfx/resource";
+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 ${Resource.Identifier.toString(identifier)}`));
+    }
+    ontology(identifier) {
+        const ontology = this.ontologiesByIdentifier.get(identifier);
+        return ontology
+            ? Either.of(ontology)
+            : Left(new Error(`no such ontology ${Resource.Identifier.toString(identifier)}`));
+    }
+    propertyGroup(identifier) {
+        const propertyGroup = this.propertyGroupsByIdentifier.get(identifier);
+        return propertyGroup
+            ? Either.of(propertyGroup)
+            : Left(new Error(`no such property group ${Resource.Identifier.toString(identifier)}`));
+    }
+    propertyShape(identifier) {
+        const propertyShape = this.propertyShapesByIdentifier.get(identifier);
+        return propertyShape
+            ? Either.of(propertyShape)
+            : Left(new Error(`no such property shape ${Resource.Identifier.toString(identifier)}`));
+    }
+    shape(identifier) {
+        return this.nodeShape(identifier).alt(this.propertyShape(identifier));
+    }
+    /**
+     * Convert the shapes graph to a dataset.
+     */
+    toDataset() {
+        const dataset = DatasetFactory.dataset();
+        const resourceSet = new ResourceSet(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";
+        function termToString(term) {
+            switch (term.termType) {
+                case "NamedNode":
+                    return `<${term.value}>`;
+                case "BlankNode":
+                    return `_:${term.value}`;
+                case "Literal": {
+                    const escaped = term.value
+                        .replace(/\\/g, "\\\\")
+                        .replace(/"/g, '\\"')
+                        .replace(/\n/g, "\\n")
+                        .replace(/\r/g, "\\r");
+                    if (term.language)
+                        return `"${escaped}"@${term.language}`;
+                    if (term.datatype.value !== "http://www.w3.org/2001/XMLSchema#string")
+                        return `"${escaped}"^^<${term.datatype.value}>`;
+                    return `"${escaped}"`;
+                }
+                default:
+                    throw new Error(`unexpected term type: ${term.termType}`);
+            }
+        }
+        const lines = [];
+        switch (format) {
+            case "application/n-quads": {
+                for (const quad of this.toDataset()) {
+                    const graphString = quad.graph.termType === "DefaultGraph"
+                        ? ""
+                        : ` ${termToString(quad.graph)}`;
+                    lines.push(`${termToString(quad.subject)} ${termToString(quad.predicate)} ${termToString(quad.object)}${graphString} .\n`);
+                }
+                break;
+            }
+            case "application/n-triples":
+                {
+                    for (const quad of this.toDataset()) {
+                        lines.push(`${termToString(quad.subject)} ${termToString(quad.predicate)} ${termToString(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(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: ${Resource.Identifier.toString(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: ${Resource.Identifier.toString(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/ShapesGraph.d.ts

@@ -1,80 +1,27 @@
-import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
-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 { CurieFactory } from "./CurieFactory.js";
+import { AbstractShapesGraph } from "./AbstractShapesGraph.js";
 import * as generated from "./generated.js";
-export declare class ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends ShapeT, ShapeT extends generated.Shape> {
-    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[];
-    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, ShapeT>;
+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 {
-    export abstract class Factory<NodeShapeT extends generated.NodeShape & ShapeT, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends generated.PropertyShape & ShapeT, ShapeT extends generated.Shape> {
-        protected preferredLanguages: readonly string[];
-        constructor(parameters?: {
-            preferredLanguages?: readonly string[];
-        });
-        createShapesGraph({ dataset, prefixMap, ignoreUndefinedShapes, }: {
-            dataset: DatasetCore;
-            prefixMap?: PrefixMap;
-            ignoreUndefinedShapes?: boolean;
-        }): Either<Error, ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>>;
-        protected abstract createNodeShape(parameters: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        }): Either<Error, NodeShapeT>;
-        protected abstract createOntology(parameters: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        }): Either<Error, OntologyT>;
-        protected abstract createPropertyGroup(parameters: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        }): Either<Error, PropertyGroupT>;
-        protected abstract createPropertyShape(parameters: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-            shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        }): Either<Error, PropertyShapeT>;
+    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.$create>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.$create>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.$create>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.$create>[0]): generated.PropertyShape;
     }
-    type DefaultShapesGraph = ShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, generated.Shape>;
-    class DefaultFactory extends Factory<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, generated.Shape> {
-        protected createNodeShape({ resource }: {
-            resource: Resource;
-        }): Either<Error, generated.NodeShape>;
-        protected createOntology({ resource, }: {
-            resource: Resource;
-        }): Either<Error, generated.Ontology>;
-        protected createPropertyGroup({ resource, }: {
-            resource: Resource;
-        }): Either<Error, generated.PropertyGroup>;
-        protected createPropertyShape({ curieFactory, resource, }: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-        }): Either<Error, generated.PropertyShape>;
-    }
-    export function create(parameters: Parameters<DefaultFactory["createShapesGraph"]>[0]): Either<Error, DefaultShapesGraph>;
-    export {};
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map