@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/input/generated.js

@@ -2,208 +2,241 @@ import { DataFactory as dataFactory } from "n3";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
 import { PropertyPath } from "./PropertyPath.js";
-export var BaseShaclCoreShape;
-(function (BaseShaclCoreShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+export var $RdfVocabularies;
+(function ($RdfVocabularies) {
+    let rdf;
+    (function (rdf) {
+        rdf.first = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
+        rdf.nil = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
+        rdf.rest = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
+        rdf.subject = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
+        rdf.type = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+    })(rdf = $RdfVocabularies.rdf || ($RdfVocabularies.rdf = {}));
+    let rdfs;
+    (function (rdfs) {
+        rdfs.subClassOf = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
+    })(rdfs = $RdfVocabularies.rdfs || ($RdfVocabularies.rdfs = {}));
+    let xsd;
+    (function (xsd) {
+        xsd.boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
+        xsd.date = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date");
+        xsd.dateTime = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
+        xsd.integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
+    })(xsd = $RdfVocabularies.xsd || ($RdfVocabularies.xsd = {}));
+})($RdfVocabularies || ($RdfVocabularies = {}));
+export var BaseShaclCoreShapeStatic;
+(function (BaseShaclCoreShapeStatic) {
+    let $Identifier;
+    (function ($Identifier) {
+        function fromString(identifier) {
+            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
+                dataFactory,
+                identifier,
+            }));
+        }
+        $Identifier.fromString = fromString;
+        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+    })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const identifier = _resource.identifier;
-        const _andEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((value) => value.toList())
-                .map((values) => values.flatMap((_value) => _value
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()))
-                .toMaybe()
-                .toList()),
-        ]);
+    ...$context }) {
+        const $identifier = $resource.identifier;
+        const _andEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.and["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toList())
+            .chain((values) => purify.Either.sequence(values.map((value) => value
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier()))))));
         if (_andEither.isLeft()) {
             return _andEither;
         }
         const and = _andEither.unsafeCoerce();
-        const _classesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _classesEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.classes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri())));
         if (_classesEither.isLeft()) {
             return _classesEither;
         }
         const classes = _classesEither.unsafeCoerce();
-        const _commentsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _commentsEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.comments["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_commentsEither.isLeft()) {
             return _commentsEither;
         }
         const comments = _commentsEither.unsafeCoerce();
-        const _datatypeEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), {
-            unique: true,
-        })
+        const _datatypeEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toIri())
-            .toMaybe());
+            .chain((value) => value.toIri())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_datatypeEither.isLeft()) {
             return _datatypeEither;
         }
         const datatype = _datatypeEither.unsafeCoerce();
-        const _deactivatedEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), { unique: true })
+        const _deactivatedEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_deactivatedEither.isLeft()) {
             return _deactivatedEither;
         }
         const deactivated = _deactivatedEither.unsafeCoerce();
-        const _flagsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toString())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _flagsEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.flags["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toString())));
         if (_flagsEither.isLeft()) {
             return _flagsEither;
         }
         const flags = _flagsEither.unsafeCoerce();
-        const _hasValuesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => purify.Either.of(_value.toTerm()))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _hasValuesEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+            switch (term.termType) {
+                case "Literal":
+                case "NamedNode":
+                    return purify.Either.of(term);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: term,
+                        expectedValueType: "(rdfjs.Literal | rdfjs.NamedNode)",
+                        focusResource: $resource,
+                        predicate: BaseShaclCoreShapeStatic.$properties.hasValues["identifier"],
+                    }));
+            }
+        }))));
         if (_hasValuesEither.isLeft()) {
             return _hasValuesEither;
         }
         const hasValues = _hasValuesEither.unsafeCoerce();
-        const _in_Either = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), {
-            unique: true,
-        })
+        const _in_Either = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.in_["identifier"], { unique: true })
             .head()
             .chain((value) => value.toList())
-            .map((values) => values.flatMap((_value) => _value
+            .chain((values) => purify.Either.sequence(values.map((value) => value
             .toValues()
             .head()
-            .chain((_value) => purify.Either.of(_value.toTerm()))
-            .toMaybe()
-            .toList()))
-            .toMaybe());
+            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+            switch (term.termType) {
+                case "Literal":
+                case "NamedNode":
+                    return purify.Either.of(term);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: term,
+                        expectedValueType: "(rdfjs.Literal | rdfjs.NamedNode)",
+                        focusResource: $resource,
+                        predicate: BaseShaclCoreShapeStatic.$properties.in_["identifier"],
+                    }));
+            }
+        })))))
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_in_Either.isLeft()) {
             return _in_Either;
         }
         const in_ = _in_Either.unsafeCoerce();
-        const _isDefinedByEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), { unique: true })
+        const _isDefinedByEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toIdentifier())
-            .toMaybe());
+            .chain((value) => value.toIdentifier())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_isDefinedByEither.isLeft()) {
             return _isDefinedByEither;
         }
         const isDefinedBy = _isDefinedByEither.unsafeCoerce();
-        const _labelsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _labelsEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.labels["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        const _languageInEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), { unique: true })
+        const _languageInEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], { unique: true })
             .head()
             .chain((value) => value.toList())
-            .map((values) => values.flatMap((_value) => _value
+            .chain((values) => purify.Either.sequence(values.map((value) => value
             .toValues()
             .head()
-            .chain((_value) => _value.toString())
-            .toMaybe()
-            .toList()))
-            .toMaybe());
+            .chain((value) => value.toString()))))
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_languageInEither.isLeft()) {
             return _languageInEither;
         }
         const languageIn = _languageInEither.unsafeCoerce();
-        const _maxCountEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), {
-            unique: true,
-        })
+        const _maxCountEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toNumber())
-            .toMaybe());
+            .chain((value) => value.toNumber())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_maxCountEither.isLeft()) {
             return _maxCountEither;
         }
         const maxCount = _maxCountEither.unsafeCoerce();
-        const _maxExclusiveEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), { unique: true })
+        const _maxExclusiveEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], { unique: true })
             .filter((_value) => {
-            const _languageInOrDefault = _languageIn ?? [];
+            const _languageInOrDefault = $languageIn ?? [];
             if (_languageInOrDefault.length === 0) {
                 return true;
             }
@@ -214,16 +247,19 @@ export var BaseShaclCoreShape;
             return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
         })
             .head()
-            .chain((_value) => _value.toLiteral())
-            .toMaybe());
+            .chain((value) => value.toLiteral())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_maxExclusiveEither.isLeft()) {
             return _maxExclusiveEither;
         }
         const maxExclusive = _maxExclusiveEither.unsafeCoerce();
-        const _maxInclusiveEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), { unique: true })
+        const _maxInclusiveEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], { unique: true })
             .filter((_value) => {
-            const _languageInOrDefault = _languageIn ?? [];
+            const _languageInOrDefault = $languageIn ?? [];
             if (_languageInOrDefault.length === 0) {
                 return true;
             }
@@ -234,38 +270,43 @@ export var BaseShaclCoreShape;
             return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
         })
             .head()
-            .chain((_value) => _value.toLiteral())
-            .toMaybe());
+            .chain((value) => value.toLiteral())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_maxInclusiveEither.isLeft()) {
             return _maxInclusiveEither;
         }
         const maxInclusive = _maxInclusiveEither.unsafeCoerce();
-        const _maxLengthEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), {
-            unique: true,
-        })
+        const _maxLengthEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toNumber())
-            .toMaybe());
+            .chain((value) => value.toNumber())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_maxLengthEither.isLeft()) {
             return _maxLengthEither;
         }
         const maxLength = _maxLengthEither.unsafeCoerce();
-        const _minCountEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), {
-            unique: true,
-        })
+        const _minCountEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toNumber())
-            .toMaybe());
+            .chain((value) => value.toNumber())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_minCountEither.isLeft()) {
             return _minCountEither;
         }
         const minCount = _minCountEither.unsafeCoerce();
-        const _minExclusiveEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), { unique: true })
+        const _minExclusiveEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], { unique: true })
             .filter((_value) => {
-            const _languageInOrDefault = _languageIn ?? [];
+            const _languageInOrDefault = $languageIn ?? [];
             if (_languageInOrDefault.length === 0) {
                 return true;
             }
@@ -276,16 +317,19 @@ export var BaseShaclCoreShape;
             return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
         })
             .head()
-            .chain((_value) => _value.toLiteral())
-            .toMaybe());
+            .chain((value) => value.toLiteral())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_minExclusiveEither.isLeft()) {
             return _minExclusiveEither;
         }
         const minExclusive = _minExclusiveEither.unsafeCoerce();
-        const _minInclusiveEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), { unique: true })
+        const _minInclusiveEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], { unique: true })
             .filter((_value) => {
-            const _languageInOrDefault = _languageIn ?? [];
+            const _languageInOrDefault = $languageIn ?? [];
             if (_languageInOrDefault.length === 0) {
                 return true;
             }
@@ -296,29 +340,31 @@ export var BaseShaclCoreShape;
             return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
         })
             .head()
-            .chain((_value) => _value.toLiteral())
-            .toMaybe());
+            .chain((value) => value.toLiteral())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_minInclusiveEither.isLeft()) {
             return _minInclusiveEither;
         }
         const minInclusive = _minInclusiveEither.unsafeCoerce();
-        const _minLengthEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), {
-            unique: true,
-        })
+        const _minLengthEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toNumber())
-            .toMaybe());
+            .chain((value) => value.toNumber())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_minLengthEither.isLeft()) {
             return _minLengthEither;
         }
         const minLength = _minLengthEither.unsafeCoerce();
-        const _nodeKindEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), {
-            unique: true,
-        })
+        const _nodeKindEither = $resource
+            .values(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toIri().chain((iri) => {
+            .chain((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://www.w3.org/ns/shacl#BlankNode":
                     return purify.Either.of(iri);
@@ -336,110 +382,79 @@ export var BaseShaclCoreShape;
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
                         expectedValueType: 'rdfjs.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">',
-                        focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                        focusResource: $resource,
+                        predicate: BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"],
                     }));
             }
         }))
-            .toMaybe());
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_nodeKindEither.isLeft()) {
             return _nodeKindEither;
         }
         const nodeKind = _nodeKindEither.unsafeCoerce();
-        const _nodesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _nodesEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier())));
         if (_nodesEither.isLeft()) {
             return _nodesEither;
         }
         const nodes = _nodesEither.unsafeCoerce();
-        const _notEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _notEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.not["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier())));
         if (_notEither.isLeft()) {
             return _notEither;
         }
         const not = _notEither.unsafeCoerce();
-        const _orEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((value) => value.toList())
-                .map((values) => values.flatMap((_value) => _value
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _orEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.or["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toList())
+            .chain((values) => purify.Either.sequence(values.map((value) => value
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier()))))));
         if (_orEither.isLeft()) {
             return _orEither;
         }
         const or = _orEither.unsafeCoerce();
-        const _patternsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toString())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _patternsEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toString())));
         if (_patternsEither.isLeft()) {
             return _patternsEither;
         }
         const patterns = _patternsEither.unsafeCoerce();
-        const _xoneEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((value) => value.toList())
-                .map((values) => values.flatMap((_value) => _value
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _xoneEither = purify.Either.sequence($resource
+            .values(BaseShaclCoreShapeStatic.$properties.xone["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toList())
+            .chain((values) => purify.Either.sequence(values.map((value) => value
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier()))))));
         if (_xoneEither.isLeft()) {
             return _xoneEither;
         }
         const xone = _xoneEither.unsafeCoerce();
         return purify.Either.of({
-            identifier,
+            $identifier,
             and,
             classes,
             comments,
@@ -467,150 +482,355 @@ export var BaseShaclCoreShape;
             xone,
         });
     }
-    BaseShaclCoreShape._propertiesFromRdf = _propertiesFromRdf;
-})(BaseShaclCoreShape || (BaseShaclCoreShape = {}));
-export var ShaclCorePropertyShape;
-(function (ShaclCorePropertyShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    BaseShaclCoreShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        const { ignoreRdfType: _, ...otherParameters } = parameters;
+        return ShaclCoreNodeShapeStatic.$fromRdf(otherParameters).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf(otherParameters));
+    }
+    BaseShaclCoreShapeStatic.$fromRdf = $fromRdf;
+    function $toRdf(_baseShaclCoreShape, { mutateGraph, resourceSet, }) {
+        const _resource = resourceSet.mutableResource(_baseShaclCoreShape.$identifier, { mutateGraph });
+        _resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], _baseShaclCoreShape.and.map((item) => item.length > 0
+            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], _baseShaclCoreShape.classes.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.comments["identifier"], _baseShaclCoreShape.comments.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], _baseShaclCoreShape.datatype);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], _baseShaclCoreShape.deactivated);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.flags["identifier"], _baseShaclCoreShape.flags.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], _baseShaclCoreShape.hasValues.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.in_["identifier"], _baseShaclCoreShape.in_.map((value) => value.length > 0
+            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], _baseShaclCoreShape.isDefinedBy);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], _baseShaclCoreShape.labels.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], _baseShaclCoreShape.languageIn.map((value) => value.length > 0
+            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], _baseShaclCoreShape.maxCount);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], _baseShaclCoreShape.maxExclusive);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], _baseShaclCoreShape.maxInclusive);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], _baseShaclCoreShape.maxLength);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], _baseShaclCoreShape.minCount);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], _baseShaclCoreShape.minExclusive);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], _baseShaclCoreShape.minInclusive);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], _baseShaclCoreShape.minLength);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], _baseShaclCoreShape.nodeKind);
+        _resource.add(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], _baseShaclCoreShape.nodes.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.not["identifier"], _baseShaclCoreShape.not.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.or["identifier"], _baseShaclCoreShape.or.map((item) => item.length > 0
+            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], _baseShaclCoreShape.patterns.map((item) => item));
+        _resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], _baseShaclCoreShape.xone.map((item) => item.length > 0
+            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        return _resource;
+    }
+    BaseShaclCoreShapeStatic.$toRdf = $toRdf;
+    BaseShaclCoreShapeStatic.$properties = {
+        and: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+        },
+        classes: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+        },
+        comments: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+        },
+        datatype: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+        },
+        deactivated: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+        },
+        flags: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+        },
+        hasValues: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+        },
+        in_: { identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#in") },
+        isDefinedBy: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+        },
+        labels: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+        },
+        languageIn: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+        },
+        maxCount: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+        },
+        maxExclusive: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+        },
+        maxInclusive: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+        },
+        maxLength: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+        },
+        minCount: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+        },
+        minExclusive: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+        },
+        minInclusive: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+        },
+        minLength: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+        },
+        nodeKind: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+        },
+        nodes: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+        },
+        not: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+        },
+        or: { identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#or") },
+        patterns: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+        },
+        xone: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+        },
+    };
+})(BaseShaclCoreShapeStatic || (BaseShaclCoreShapeStatic = {}));
+export var ShaclCorePropertyShapeStatic;
+(function (ShaclCorePropertyShapeStatic) {
+    ShaclCorePropertyShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    ShaclCorePropertyShapeStatic.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const _super0Either = BaseShaclCoreShape._propertiesFromRdf({
-            ..._context,
+    ...$context }) {
+        const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
-            resource: _resource,
+            languageIn: $languageIn,
+            resource: $resource,
         });
-        if (_super0Either.isLeft()) {
-            return _super0Either;
-        }
-        const _super0 = _super0Either.unsafeCoerce();
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
-            }));
-        }
-        const identifier = _resource.identifier;
-        const type = "ShaclCorePropertyShape";
-        const _defaultValueEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), { unique: true })
+        if ($super0Either.isLeft()) {
+            return $super0Either;
+        }
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyShapeStatic.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclCorePropertyShape";
+        const _defaultValueEither = $resource
+            .values(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], { unique: true })
             .head()
-            .chain((_value) => purify.Either.of(_value.toTerm()))
-            .toMaybe());
+            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+            switch (term.termType) {
+                case "Literal":
+                case "NamedNode":
+                    return purify.Either.of(term);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: term,
+                        expectedValueType: "(rdfjs.Literal | rdfjs.NamedNode)",
+                        focusResource: $resource,
+                        predicate: ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"],
+                    }));
+            }
+        }))
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_defaultValueEither.isLeft()) {
             return _defaultValueEither;
         }
         const defaultValue = _defaultValueEither.unsafeCoerce();
-        const _descriptionsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _descriptionsEither = purify.Either.sequence($resource
+            .values(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_descriptionsEither.isLeft()) {
             return _descriptionsEither;
         }
         const descriptions = _descriptionsEither.unsafeCoerce();
-        const _groupsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _groupsEither = purify.Either.sequence($resource
+            .values(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier())));
         if (_groupsEither.isLeft()) {
             return _groupsEither;
         }
         const groups = _groupsEither.unsafeCoerce();
-        const _namesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _namesEither = purify.Either.sequence($resource
+            .values(ShaclCorePropertyShapeStatic.$properties.names["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_namesEither.isLeft()) {
             return _namesEither;
         }
         const names = _namesEither.unsafeCoerce();
-        const _orderEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), {
-            unique: true,
-        })
+        const _orderEither = $resource
+            .values(ShaclCorePropertyShapeStatic.$properties.order["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toNumber())
-            .toMaybe());
+            .chain((value) => value.toNumber())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_orderEither.isLeft()) {
             return _orderEither;
         }
         const order = _orderEither.unsafeCoerce();
-        const _pathEither = _resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), {
-            unique: true,
-        })
+        const _pathEither = $resource
+            .values(ShaclCorePropertyShapeStatic.$properties.path["identifier"], { unique: true })
             .head()
             .chain((value) => value.toResource())
-            .chain((_resource) => PropertyPath.fromRdf({
-            ..._context,
+            .chain((_resource) => PropertyPath.$fromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
+            languageIn: $languageIn,
             resource: _resource,
         }));
         if (_pathEither.isLeft()) {
             return _pathEither;
         }
         const path = _pathEither.unsafeCoerce();
-        const _uniqueLangEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), { unique: true })
+        const _uniqueLangEither = $resource
+            .values(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_uniqueLangEither.isLeft()) {
             return _uniqueLangEither;
         }
         const uniqueLang = _uniqueLangEither.unsafeCoerce();
         return purify.Either.of({
-            ..._super0,
-            identifier,
-            type,
+            ...$super0,
+            $identifier,
+            $type,
             defaultValue,
             descriptions,
             groups,
@@ -620,69 +840,137 @@ export var ShaclCorePropertyShape;
             uniqueLang,
         });
     }
-    ShaclCorePropertyShape._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclCorePropertyShape._propertiesFromRdf(parameters);
+    ShaclCorePropertyShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        const { ignoreRdfType: _, ...otherParameters } = parameters;
+        return ShaclmatePropertyShape.$fromRdf(otherParameters).altLazy(() => ShaclCorePropertyShapeStatic.$propertiesFromRdf(parameters));
     }
-    ShaclCorePropertyShape.fromRdf = fromRdf;
-    ShaclCorePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
-})(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
+    ShaclCorePropertyShapeStatic.$fromRdf = $fromRdf;
+    function $toRdf(_shaclCorePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCorePropertyShape, {
+            ignoreRdfType: true,
+            mutateGraph,
+            resourceSet,
+        });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCorePropertyShape"));
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
+        }
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.order["identifier"], _shaclCorePropertyShape.order);
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+            mutateGraph: mutateGraph,
+            resourceSet: resourceSet,
+        }));
+        _resource.add(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
+        return _resource;
+    }
+    ShaclCorePropertyShapeStatic.$toRdf = $toRdf;
+    ShaclCorePropertyShapeStatic.$properties = {
+        ...BaseShaclCoreShapeStatic.$properties,
+        defaultValue: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
+        },
+        descriptions: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+        },
+        groups: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+        },
+        names: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+        },
+        order: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+        },
+        path: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+        },
+        uniqueLang: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+        },
+    };
+})(ShaclCorePropertyShapeStatic || (ShaclCorePropertyShapeStatic = {}));
 export var ShaclmatePropertyShape;
 (function (ShaclmatePropertyShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    ShaclmatePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    ShaclmatePropertyShape.$Identifier = ShaclCorePropertyShapeStatic.$Identifier;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const _super0Either = ShaclCorePropertyShape._propertiesFromRdf({
-            ..._context,
+    ...$context }) {
+        const $super0Either = ShaclCorePropertyShapeStatic.$propertiesFromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
-            resource: _resource,
+            languageIn: $languageIn,
+            resource: $resource,
         });
-        if (_super0Either.isLeft()) {
-            return _super0Either;
-        }
-        const _super0 = _super0Either.unsafeCoerce();
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
-            }));
-        }
-        const identifier = _resource.identifier;
-        const type = "ShaclmatePropertyShape";
-        const _externEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"), { unique: true })
+        if ($super0Either.isLeft()) {
+            return $super0Either;
+        }
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclmatePropertyShape.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclmatePropertyShape";
+        const _lazyEither = $resource
+            .values(ShaclmatePropertyShape.$properties.lazy["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
-        if (_externEither.isLeft()) {
-            return _externEither;
-        }
-        const extern = _externEither.unsafeCoerce();
-        const _mutableEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"), { unique: true })
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
+        if (_lazyEither.isLeft()) {
+            return _lazyEither;
+        }
+        const lazy = _lazyEither.unsafeCoerce();
+        const _mutableEither = $resource
+            .values(ShaclmatePropertyShape.$properties.mutable["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_mutableEither.isLeft()) {
             return _mutableEither;
         }
         const mutable = _mutableEither.unsafeCoerce();
-        const _nameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), { unique: true })
+        const _nameEither = $resource
+            .values(ShaclmatePropertyShape.$properties.name["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
+            .chain((value) => value.toString())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_nameEither.isLeft()) {
             return _nameEither;
         }
         const name = _nameEither.unsafeCoerce();
-        const _visibilityEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#visibility"), { unique: true })
+        const _stubEither = $resource
+            .values(ShaclmatePropertyShape.$properties.stub["identifier"], { unique: true })
+            .head()
+            .chain((value) => value.toIdentifier())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
+        if (_stubEither.isLeft()) {
+            return _stubEither;
+        }
+        const stub = _stubEither.unsafeCoerce();
+        const _visibilityEither = $resource
+            .values(ShaclmatePropertyShape.$properties.visibility["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toIri().chain((iri) => {
+            .chain((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_Visibility_Private":
                     return purify.Either.of(iri);
@@ -694,238 +982,277 @@ export var ShaclmatePropertyShape;
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
                         expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">',
-                        focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#visibility"),
+                        focusResource: $resource,
+                        predicate: ShaclmatePropertyShape.$properties.visibility["identifier"],
                     }));
             }
         }))
-            .toMaybe());
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_visibilityEither.isLeft()) {
             return _visibilityEither;
         }
         const visibility = _visibilityEither.unsafeCoerce();
+        const _widenEither = $resource
+            .values(ShaclmatePropertyShape.$properties.widen["identifier"], { unique: true })
+            .head()
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
+        if (_widenEither.isLeft()) {
+            return _widenEither;
+        }
+        const widen = _widenEither.unsafeCoerce();
         return purify.Either.of({
-            ..._super0,
-            identifier,
-            type,
-            extern,
+            ...$super0,
+            $identifier,
+            $type,
+            lazy,
             mutable,
             name,
+            stub,
             visibility,
+            widen,
         });
     }
-    ShaclmatePropertyShape._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclmatePropertyShape._propertiesFromRdf(parameters);
+    ShaclmatePropertyShape.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclmatePropertyShape.$propertiesFromRdf(parameters);
+    }
+    ShaclmatePropertyShape.$fromRdf = $fromRdf;
+    function $toRdf(_shaclmatePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = ShaclCorePropertyShapeStatic.$toRdf(_shaclmatePropertyShape, { ignoreRdfType: true, mutateGraph, resourceSet });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
+        }
+        _resource.add(ShaclmatePropertyShape.$properties.lazy["identifier"], _shaclmatePropertyShape.lazy);
+        _resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmatePropertyShape.mutable);
+        _resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmatePropertyShape.name);
+        _resource.add(ShaclmatePropertyShape.$properties.stub["identifier"], _shaclmatePropertyShape.stub);
+        _resource.add(ShaclmatePropertyShape.$properties.visibility["identifier"], _shaclmatePropertyShape.visibility);
+        _resource.add(ShaclmatePropertyShape.$properties.widen["identifier"], _shaclmatePropertyShape.widen);
+        return _resource;
     }
-    ShaclmatePropertyShape.fromRdf = fromRdf;
-    ShaclmatePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    ShaclmatePropertyShape.$toRdf = $toRdf;
+    ShaclmatePropertyShape.$properties = {
+        ...ShaclCorePropertyShapeStatic.$properties,
+        lazy: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#lazy"),
+        },
+        mutable: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+        },
+        name: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+        },
+        stub: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#stub"),
+        },
+        visibility: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#visibility"),
+        },
+        widen: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#widen"),
+        },
+    };
 })(ShaclmatePropertyShape || (ShaclmatePropertyShape = {}));
-export var OwlOntology;
-(function (OwlOntology) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
-    // @ts-ignore
-    ..._context }) {
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+export var OwlOntologyStatic;
+(function (OwlOntologyStatic) {
+    OwlOntologyStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    let $Identifier;
+    (function ($Identifier) {
+        function fromString(identifier) {
+            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
+                dataFactory,
+                identifier,
             }));
         }
-        const identifier = _resource.identifier;
-        const type = "OwlOntology";
-        const _labelsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        $Identifier.fromString = fromString;
+        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+    })($Identifier = OwlOntologyStatic.$Identifier || (OwlOntologyStatic.$Identifier = {}));
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    // @ts-ignore
+    ...$context }) {
+        if (!$ignoreRdfType && !$resource.isInstanceOf(OwlOntologyStatic.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "OwlOntology";
+        const _labelsEither = purify.Either.sequence($resource
+            .values(OwlOntologyStatic.$properties.labels["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        return purify.Either.of({ identifier, type, labels });
+        return purify.Either.of({ $identifier, $type, labels });
     }
-    OwlOntology._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return OwlOntology._propertiesFromRdf(parameters);
+    OwlOntologyStatic.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        const { ignoreRdfType: _, ...otherParameters } = parameters;
+        return ShaclmateOntology.$fromRdf(otherParameters).altLazy(() => OwlOntologyStatic.$propertiesFromRdf(parameters));
     }
-    OwlOntology.fromRdf = fromRdf;
-    OwlOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
-})(OwlOntology || (OwlOntology = {}));
+    OwlOntologyStatic.$fromRdf = $fromRdf;
+    function $toRdf(_owlOntology, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = resourceSet.mutableResource(_owlOntology.$identifier, {
+            mutateGraph,
+        });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#OwlOntology"));
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
+        }
+        _resource.add(OwlOntologyStatic.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
+        return _resource;
+    }
+    OwlOntologyStatic.$toRdf = $toRdf;
+    OwlOntologyStatic.$properties = {
+        labels: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+        },
+    };
+})(OwlOntologyStatic || (OwlOntologyStatic = {}));
 export var ShaclmateOntology;
 (function (ShaclmateOntology) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    ShaclmateOntology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    ShaclmateOntology.$Identifier = OwlOntologyStatic.$Identifier;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const _super0Either = OwlOntology._propertiesFromRdf({
-            ..._context,
+    ...$context }) {
+        const $super0Either = OwlOntologyStatic.$propertiesFromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
-            resource: _resource,
+            languageIn: $languageIn,
+            resource: $resource,
         });
-        if (_super0Either.isLeft()) {
-            return _super0Either;
-        }
-        const _super0 = _super0Either.unsafeCoerce();
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
-            }));
-        }
-        const identifier = _resource.identifier;
-        const type = "ShaclmateOntology";
-        const _tsDataFactoryVariableEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsDataFactoryVariable"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsDataFactoryVariableEither.isLeft()) {
-            return _tsDataFactoryVariableEither;
-        }
-        const tsDataFactoryVariable = _tsDataFactoryVariableEither.unsafeCoerce();
-        const _tsFeatureExcludesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri().chain((iri) => {
-                switch (iri.value) {
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_None":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-                        return purify.Either.of(iri);
-                    default:
-                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
-                            actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">',
-                            focusResource: _resource,
-                            predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
-                        }));
-                }
-            }))
-                .toMaybe()
-                .toList()),
-        ]);
+        if ($super0Either.isLeft()) {
+            return $super0Either;
+        }
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclmateOntology.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclmateOntology";
+        const _tsFeatureExcludesEither = purify.Either.sequence($resource
+            .values(ShaclmateOntology.$properties.tsFeatureExcludes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">',
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
+                    }));
+            }
+        }))));
         if (_tsFeatureExcludesEither.isLeft()) {
             return _tsFeatureExcludesEither;
         }
         const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
-        const _tsFeatureIncludesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri().chain((iri) => {
-                switch (iri.value) {
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_None":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-                        return purify.Either.of(iri);
-                    default:
-                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
-                            actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">',
-                            focusResource: _resource,
-                            predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
-                        }));
-                }
-            }))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _tsFeatureIncludesEither = purify.Either.sequence($resource
+            .values(ShaclmateOntology.$properties.tsFeatureIncludes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">',
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
+                    }));
+            }
+        }))));
         if (_tsFeatureIncludesEither.isLeft()) {
             return _tsFeatureIncludesEither;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
-        const _tsImportsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toString())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _tsImportsEither = purify.Either.sequence($resource
+            .values(ShaclmateOntology.$properties.tsImports["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toString())));
         if (_tsImportsEither.isLeft()) {
             return _tsImportsEither;
         }
         const tsImports = _tsImportsEither.unsafeCoerce();
-        const _tsObjectDeclarationTypeEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), { unique: true })
+        const _tsObjectDeclarationTypeEither = $resource
+            .values(ShaclmateOntology.$properties.tsObjectDeclarationType["identifier"], {
+            unique: true,
+        })
             .head()
-            .chain((_value) => _value.toIri().chain((iri) => {
+            .chain((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return purify.Either.of(iri);
@@ -935,212 +1262,271 @@ export var ShaclmateOntology;
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
                         expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">',
-                        focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
                     }));
             }
         }))
-            .toMaybe());
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_tsObjectDeclarationTypeEither.isLeft()) {
             return _tsObjectDeclarationTypeEither;
         }
         const tsObjectDeclarationType = _tsObjectDeclarationTypeEither.unsafeCoerce();
-        const _tsObjectIdentifierPrefixPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectIdentifierPrefixPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectIdentifierPrefixPropertyNameEither.isLeft()) {
-            return _tsObjectIdentifierPrefixPropertyNameEither;
-        }
-        const tsObjectIdentifierPrefixPropertyName = _tsObjectIdentifierPrefixPropertyNameEither.unsafeCoerce();
-        const _tsObjectIdentifierPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectIdentifierPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectIdentifierPropertyNameEither.isLeft()) {
-            return _tsObjectIdentifierPropertyNameEither;
-        }
-        const tsObjectIdentifierPropertyName = _tsObjectIdentifierPropertyNameEither.unsafeCoerce();
-        const _tsObjectTypeDiscriminatorPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectTypeDiscriminatorPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectTypeDiscriminatorPropertyNameEither.isLeft()) {
-            return _tsObjectTypeDiscriminatorPropertyNameEither;
-        }
-        const tsObjectTypeDiscriminatorPropertyName = _tsObjectTypeDiscriminatorPropertyNameEither.unsafeCoerce();
         return purify.Either.of({
-            ..._super0,
-            identifier,
-            type,
-            tsDataFactoryVariable,
+            ...$super0,
+            $identifier,
+            $type,
             tsFeatureExcludes,
             tsFeatureIncludes,
             tsImports,
             tsObjectDeclarationType,
-            tsObjectIdentifierPrefixPropertyName,
-            tsObjectIdentifierPropertyName,
-            tsObjectTypeDiscriminatorPropertyName,
         });
     }
-    ShaclmateOntology._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclmateOntology._propertiesFromRdf(parameters);
+    ShaclmateOntology.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclmateOntology.$propertiesFromRdf(parameters);
     }
-    ShaclmateOntology.fromRdf = fromRdf;
-    ShaclmateOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    ShaclmateOntology.$fromRdf = $fromRdf;
+    function $toRdf(_shaclmateOntology, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = OwlOntologyStatic.$toRdf(_shaclmateOntology, {
+            ignoreRdfType: true,
+            mutateGraph,
+            resourceSet,
+        });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
+        }
+        _resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateOntology.tsFeatureExcludes.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateOntology.tsFeatureIncludes.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateOntology.tsImports.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateOntology.tsObjectDeclarationType);
+        return _resource;
+    }
+    ShaclmateOntology.$toRdf = $toRdf;
+    ShaclmateOntology.$properties = {
+        ...OwlOntologyStatic.$properties,
+        tsFeatureExcludes: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
+        },
+        tsFeatureIncludes: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
+        },
+        tsImports: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
+        },
+        tsObjectDeclarationType: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
+        },
+    };
 })(ShaclmateOntology || (ShaclmateOntology = {}));
-export var ShaclCoreNodeShape;
-(function (ShaclCoreNodeShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+export var ShaclCoreNodeShapeStatic;
+(function (ShaclCoreNodeShapeStatic) {
+    ShaclCoreNodeShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
+    ShaclCoreNodeShapeStatic.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const _super0Either = BaseShaclCoreShape._propertiesFromRdf({
-            ..._context,
+    ...$context }) {
+        const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
-            resource: _resource,
+            languageIn: $languageIn,
+            resource: $resource,
         });
-        if (_super0Either.isLeft()) {
-            return _super0Either;
-        }
-        const _super0 = _super0Either.unsafeCoerce();
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
-            }));
-        }
-        const identifier = _resource.identifier;
-        const type = "ShaclCoreNodeShape";
-        const _closedEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), {
-            unique: true,
-        })
+        if ($super0Either.isLeft()) {
+            return $super0Either;
+        }
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCoreNodeShapeStatic.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclCoreNodeShape";
+        const _closedEither = $resource
+            .values(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_closedEither.isLeft()) {
             return _closedEither;
         }
         const closed = _closedEither.unsafeCoerce();
-        const _ignoredPropertiesEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), { unique: true })
+        const _ignoredPropertiesEither = $resource
+            .values(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], { unique: true })
             .head()
             .chain((value) => value.toList())
-            .map((values) => values.flatMap((_value) => _value
+            .chain((values) => purify.Either.sequence(values.map((value) => value
             .toValues()
             .head()
-            .chain((_value) => _value.toIri())
-            .toMaybe()
-            .toList()))
-            .toMaybe());
+            .chain((value) => value.toIri()))))
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_ignoredPropertiesEither.isLeft()) {
             return _ignoredPropertiesEither;
         }
         const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
-        const _propertiesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), {
-                unique: true,
-            })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIdentifier())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _propertiesEither = purify.Either.sequence($resource
+            .values(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIdentifier())));
         if (_propertiesEither.isLeft()) {
             return _propertiesEither;
         }
         const properties = _propertiesEither.unsafeCoerce();
         return purify.Either.of({
-            ..._super0,
-            identifier,
-            type,
+            ...$super0,
+            $identifier,
+            $type,
             closed,
             ignoredProperties,
             properties,
         });
     }
-    ShaclCoreNodeShape._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclCoreNodeShape._propertiesFromRdf(parameters);
+    ShaclCoreNodeShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        const { ignoreRdfType: _, ...otherParameters } = parameters;
+        return ShaclmateNodeShape.$fromRdf(otherParameters).altLazy(() => ShaclCoreNodeShapeStatic.$propertiesFromRdf(parameters));
+    }
+    ShaclCoreNodeShapeStatic.$fromRdf = $fromRdf;
+    function $toRdf(_shaclCoreNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCoreNodeShape, {
+            ignoreRdfType: true,
+            mutateGraph,
+            resourceSet,
+        });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCoreNodeShape"));
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
+        }
+        _resource.add(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
+        _resource.add(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], _shaclCoreNodeShape.ignoredProperties.map((value) => value.length > 0
+            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                if (itemIndex === 0) {
+                    currentSubListResource = listResource;
+                }
+                else {
+                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                    currentSubListResource = newSubListResource;
+                }
+                currentSubListResource.add($RdfVocabularies.rdf.first, item);
+                if (itemIndex + 1 === list.length) {
+                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                }
+                return { currentSubListResource, listResource };
+            }, {
+                currentSubListResource: null,
+                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+            }).listResource.identifier
+            : $RdfVocabularies.rdf.nil));
+        _resource.add(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], _shaclCoreNodeShape.properties.map((item) => item));
+        return _resource;
     }
-    ShaclCoreNodeShape.fromRdf = fromRdf;
-    ShaclCoreNodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
-})(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
+    ShaclCoreNodeShapeStatic.$toRdf = $toRdf;
+    ShaclCoreNodeShapeStatic.$properties = {
+        ...BaseShaclCoreShapeStatic.$properties,
+        closed: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+        },
+        ignoredProperties: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+        },
+        properties: {
+            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+        },
+    };
+})(ShaclCoreNodeShapeStatic || (ShaclCoreNodeShapeStatic = {}));
 export var ShaclmateNodeShape;
 (function (ShaclmateNodeShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    ShaclmateNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
+    ShaclmateNodeShape.$Identifier = ShaclCoreNodeShapeStatic.$Identifier;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
     // @ts-ignore
-    ..._context }) {
-        const _super0Either = ShaclCoreNodeShape._propertiesFromRdf({
-            ..._context,
+    ...$context }) {
+        const $super0Either = ShaclCoreNodeShapeStatic.$propertiesFromRdf({
+            ...$context,
             ignoreRdfType: true,
-            languageIn: _languageIn,
-            resource: _resource,
+            languageIn: $languageIn,
+            resource: $resource,
         });
-        if (_super0Either.isLeft()) {
-            return _super0Either;
-        }
-        const _super0 = _super0Either.unsafeCoerce();
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
-            }));
-        }
-        const identifier = _resource.identifier;
-        const type = "ShaclmateNodeShape";
-        const _abstractEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#abstract"), { unique: true })
+        if ($super0Either.isLeft()) {
+            return $super0Either;
+        }
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclmateNodeShape.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclmateNodeShape";
+        const _abstractEither = $resource
+            .values(ShaclmateNodeShape.$properties.abstract["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_abstractEither.isLeft()) {
             return _abstractEither;
         }
         const abstract = _abstractEither.unsafeCoerce();
-        const _export_Either = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#export"), { unique: true })
+        const _export_Either = $resource
+            .values(ShaclmateNodeShape.$properties.export_["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_export_Either.isLeft()) {
             return _export_Either;
         }
         const export_ = _export_Either.unsafeCoerce();
-        const _externEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"), { unique: true })
+        const _externEither = $resource
+            .values(ShaclmateNodeShape.$properties.extern["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_externEither.isLeft()) {
             return _externEither;
         }
         const extern = _externEither.unsafeCoerce();
-        const _fromRdfTypeEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"), { unique: true })
+        const _fromRdfTypeEither = $resource
+            .values(ShaclmateNodeShape.$properties.fromRdfType["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toIri())
-            .toMaybe());
+            .chain((value) => value.toIri())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_fromRdfTypeEither.isLeft()) {
             return _fromRdfTypeEither;
         }
         const fromRdfType = _fromRdfTypeEither.unsafeCoerce();
-        const _identifierMintingStrategyEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#identifierMintingStrategy"), { unique: true })
+        const _identifierMintingStrategyEither = $resource
+            .values(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], {
+            unique: true,
+        })
             .head()
-            .chain((_value) => _value.toIri().chain((iri) => {
+            .chain((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
                     return purify.Either.of(iri);
@@ -1152,170 +1538,161 @@ export var ShaclmateNodeShape;
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
                         expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">',
-                        focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#identifierMintingStrategy"),
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"],
                     }));
             }
         }))
-            .toMaybe());
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_identifierMintingStrategyEither.isLeft()) {
             return _identifierMintingStrategyEither;
         }
         const identifierMintingStrategy = _identifierMintingStrategyEither.unsafeCoerce();
-        const _mutableEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"), { unique: true })
+        const _mutableEither = $resource
+            .values(ShaclmateNodeShape.$properties.mutable["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toBoolean())
-            .toMaybe());
+            .chain((value) => value.toBoolean())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_mutableEither.isLeft()) {
             return _mutableEither;
         }
         const mutable = _mutableEither.unsafeCoerce();
-        const _nameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), { unique: true })
+        const _nameEither = $resource
+            .values(ShaclmateNodeShape.$properties.name["identifier"], { unique: true })
             .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
+            .chain((value) => value.toString())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_nameEither.isLeft()) {
             return _nameEither;
         }
         const name = _nameEither.unsafeCoerce();
-        const _toRdfTypesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _rdfTypeEither = $resource
+            .values(ShaclmateNodeShape.$properties.rdfType["identifier"], { unique: true })
+            .head()
+            .chain((value) => value.toIri())
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
+        if (_rdfTypeEither.isLeft()) {
+            return _rdfTypeEither;
+        }
+        const rdfType = _rdfTypeEither.unsafeCoerce();
+        const _toRdfTypesEither = purify.Either.sequence($resource
+            .values(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri())));
         if (_toRdfTypesEither.isLeft()) {
             return _toRdfTypesEither;
         }
         const toRdfTypes = _toRdfTypesEither.unsafeCoerce();
-        const _tsFeatureExcludesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri().chain((iri) => {
-                switch (iri.value) {
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_None":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-                        return purify.Either.of(iri);
-                    default:
-                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
-                            actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">',
-                            focusResource: _resource,
-                            predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
-                        }));
-                }
-            }))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _tsFeatureExcludesEither = purify.Either.sequence($resource
+            .values(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">',
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
+                    }));
+            }
+        }))));
         if (_tsFeatureExcludesEither.isLeft()) {
             return _tsFeatureExcludesEither;
         }
         const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
-        const _tsFeatureIncludesEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toIri().chain((iri) => {
-                switch (iri.value) {
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_None":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-                        return purify.Either.of(iri);
-                    case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-                        return purify.Either.of(iri);
-                    default:
-                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
-                            actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">',
-                            focusResource: _resource,
-                            predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
-                        }));
-                }
-            }))
-                .toMaybe()
-                .toList()),
-        ]);
+        const _tsFeatureIncludesEither = purify.Either.sequence($resource
+            .values(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+                    return purify.Either.of(iri);
+                case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">',
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
+                    }));
+            }
+        }))));
         if (_tsFeatureIncludesEither.isLeft()) {
             return _tsFeatureIncludesEither;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
-        const _tsImportsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .head()
-                .chain((_value) => _value.toString())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _tsImportsEither = purify.Either.sequence($resource
+            .values(ShaclmateNodeShape.$properties.tsImports["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .head()
+            .chain((value) => value.toString())));
         if (_tsImportsEither.isLeft()) {
             return _tsImportsEither;
         }
         const tsImports = _tsImportsEither.unsafeCoerce();
-        const _tsObjectDeclarationTypeEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), { unique: true })
+        const _tsObjectDeclarationTypeEither = $resource
+            .values(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], {
+            unique: true,
+        })
             .head()
-            .chain((_value) => _value.toIri().chain((iri) => {
+            .chain((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return purify.Either.of(iri);
@@ -1325,47 +1702,23 @@ export var ShaclmateNodeShape;
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
                         expectedValueType: 'rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">',
-                        focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
+                        focusResource: $resource,
+                        predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
                     }));
             }
         }))
-            .toMaybe());
+            .map((value) => purify.Maybe.of(value))
+            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
+            ? purify.Right(purify.Maybe.empty())
+            : purify.Left(error));
         if (_tsObjectDeclarationTypeEither.isLeft()) {
             return _tsObjectDeclarationTypeEither;
         }
         const tsObjectDeclarationType = _tsObjectDeclarationTypeEither.unsafeCoerce();
-        const _tsObjectIdentifierPrefixPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectIdentifierPrefixPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectIdentifierPrefixPropertyNameEither.isLeft()) {
-            return _tsObjectIdentifierPrefixPropertyNameEither;
-        }
-        const tsObjectIdentifierPrefixPropertyName = _tsObjectIdentifierPrefixPropertyNameEither.unsafeCoerce();
-        const _tsObjectIdentifierPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectIdentifierPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectIdentifierPropertyNameEither.isLeft()) {
-            return _tsObjectIdentifierPropertyNameEither;
-        }
-        const tsObjectIdentifierPropertyName = _tsObjectIdentifierPropertyNameEither.unsafeCoerce();
-        const _tsObjectTypeDiscriminatorPropertyNameEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectTypeDiscriminatorPropertyName"), { unique: true })
-            .head()
-            .chain((_value) => _value.toString())
-            .toMaybe());
-        if (_tsObjectTypeDiscriminatorPropertyNameEither.isLeft()) {
-            return _tsObjectTypeDiscriminatorPropertyNameEither;
-        }
-        const tsObjectTypeDiscriminatorPropertyName = _tsObjectTypeDiscriminatorPropertyNameEither.unsafeCoerce();
         return purify.Either.of({
-            ..._super0,
-            identifier,
-            type,
+            ...$super0,
+            $identifier,
+            $type,
             abstract,
             export_,
             extern,
@@ -1373,115 +1726,658 @@ export var ShaclmateNodeShape;
             identifierMintingStrategy,
             mutable,
             name,
+            rdfType,
             toRdfTypes,
             tsFeatureExcludes,
             tsFeatureIncludes,
             tsImports,
             tsObjectDeclarationType,
-            tsObjectIdentifierPrefixPropertyName,
-            tsObjectIdentifierPropertyName,
-            tsObjectTypeDiscriminatorPropertyName,
         });
     }
-    ShaclmateNodeShape._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclmateNodeShape._propertiesFromRdf(parameters);
+    ShaclmateNodeShape.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclmateNodeShape.$propertiesFromRdf(parameters);
+    }
+    ShaclmateNodeShape.$fromRdf = $fromRdf;
+    function $toRdf(_shaclmateNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = ShaclCoreNodeShapeStatic.$toRdf(_shaclmateNodeShape, {
+            ignoreRdfType: true,
+            mutateGraph,
+            resourceSet,
+        });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
+        }
+        _resource.add(ShaclmateNodeShape.$properties.abstract["identifier"], _shaclmateNodeShape.abstract);
+        _resource.add(ShaclmateNodeShape.$properties.export_["identifier"], _shaclmateNodeShape.export_);
+        _resource.add(ShaclmateNodeShape.$properties.extern["identifier"], _shaclmateNodeShape.extern);
+        _resource.add(ShaclmateNodeShape.$properties.fromRdfType["identifier"], _shaclmateNodeShape.fromRdfType);
+        _resource.add(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], _shaclmateNodeShape.identifierMintingStrategy);
+        _resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmateNodeShape.mutable);
+        _resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmateNodeShape.name);
+        _resource.add(ShaclmateNodeShape.$properties.rdfType["identifier"], _shaclmateNodeShape.rdfType);
+        _resource.add(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], _shaclmateNodeShape.toRdfTypes.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateNodeShape.tsFeatureExcludes.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateNodeShape.tsFeatureIncludes.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateNodeShape.tsImports.map((item) => item));
+        _resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateNodeShape.tsObjectDeclarationType);
+        return _resource;
     }
-    ShaclmateNodeShape.fromRdf = fromRdf;
-    ShaclmateNodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
+    ShaclmateNodeShape.$toRdf = $toRdf;
+    ShaclmateNodeShape.$properties = {
+        ...ShaclCoreNodeShapeStatic.$properties,
+        abstract: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#abstract"),
+        },
+        export_: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#export"),
+        },
+        extern: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
+        },
+        fromRdfType: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"),
+        },
+        identifierMintingStrategy: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#identifierMintingStrategy"),
+        },
+        mutable: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+        },
+        name: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+        },
+        rdfType: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
+        },
+        toRdfTypes: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"),
+        },
+        tsFeatureExcludes: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
+        },
+        tsFeatureIncludes: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
+        },
+        tsImports: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
+        },
+        tsObjectDeclarationType: {
+            identifier: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
+        },
+    };
 })(ShaclmateNodeShape || (ShaclmateNodeShape = {}));
 export var ShaclCorePropertyGroup;
 (function (ShaclCorePropertyGroup) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
-    // @ts-ignore
-    ..._context }) {
-        if (!_ignoreRdfType &&
-            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"))) {
-            return purify.Left(new rdfjsResource.Resource.ValueError({
-                focusResource: _resource,
-                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
+    ShaclCorePropertyGroup.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
+    let $Identifier;
+    (function ($Identifier) {
+        function fromString(identifier) {
+            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
+                dataFactory,
+                identifier,
             }));
         }
-        const identifier = _resource.identifier;
-        const type = "ShaclCorePropertyGroup";
-        const _commentsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        $Identifier.fromString = fromString;
+        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+    })($Identifier = ShaclCorePropertyGroup.$Identifier || (ShaclCorePropertyGroup.$Identifier = {}));
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    // @ts-ignore
+    ...$context }) {
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyGroup.$fromRdfType)) {
+            return $resource
+                .value($RdfVocabularies.rdf.type)
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`)));
+        }
+        const $identifier = $resource.identifier;
+        const $type = "ShaclCorePropertyGroup";
+        const _commentsEither = purify.Either.sequence($resource
+            .values(ShaclCorePropertyGroup.$properties.comments["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_commentsEither.isLeft()) {
             return _commentsEither;
         }
         const comments = _commentsEither.unsafeCoerce();
-        const _labelsEither = purify.Either.of([
-            ..._resource
-                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
-                .flatMap((_item) => _item
-                .toValues()
-                .filter((_value) => {
-                const _languageInOrDefault = _languageIn ?? [];
-                if (_languageInOrDefault.length === 0) {
-                    return true;
-                }
-                const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                if (typeof _valueLiteral === "undefined") {
-                    return false;
-                }
-                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-            })
-                .head()
-                .chain((_value) => _value.toLiteral())
-                .toMaybe()
-                .toList()),
-        ]);
+        const _labelsEither = purify.Either.sequence($resource
+            .values(ShaclCorePropertyGroup.$properties.labels["identifier"], { unique: true })
+            .map((item) => item
+            .toValues()
+            .filter((_value) => {
+            const _languageInOrDefault = $languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((value) => value.toLiteral())));
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        return purify.Either.of({ identifier, type, comments, labels });
+        return purify.Either.of({ $identifier, $type, comments, labels });
     }
-    ShaclCorePropertyGroup._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclCorePropertyGroup._propertiesFromRdf(parameters);
+    ShaclCorePropertyGroup.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclCorePropertyGroup.$propertiesFromRdf(parameters);
     }
-    ShaclCorePropertyGroup.fromRdf = fromRdf;
-    ShaclCorePropertyGroup.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
+    ShaclCorePropertyGroup.$fromRdf = $fromRdf;
+    function $toRdf(_shaclCorePropertyGroup, { ignoreRdfType, mutateGraph, resourceSet, }) {
+        const _resource = resourceSet.mutableResource(_shaclCorePropertyGroup.$identifier, { mutateGraph });
+        if (!ignoreRdfType) {
+            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"));
+        }
+        _resource.add(ShaclCorePropertyGroup.$properties.comments["identifier"], _shaclCorePropertyGroup.comments.map((item) => item));
+        _resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], _shaclCorePropertyGroup.labels.map((item) => item));
+        return _resource;
+    }
+    ShaclCorePropertyGroup.$toRdf = $toRdf;
+    ShaclCorePropertyGroup.$properties = {
+        comments: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+        },
+        labels: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+        },
+    };
 })(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
-    function fromRdf({ ignoreRdfType, resource, ...context }) {
-        return ShaclCoreNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+    function $fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclCoreNodeShapeStatic.$fromRdf({
+            ...context,
+            resource,
+        }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf({
             ...context,
             resource,
         }));
     }
-    ShaclCoreShape.fromRdf = fromRdf;
+    ShaclCoreShape.$fromRdf = $fromRdf;
+    let $Identifier;
+    (function ($Identifier) {
+        function fromString(identifier) {
+            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
+                dataFactory,
+                identifier,
+            }));
+        }
+        $Identifier.fromString = fromString;
+        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+    })($Identifier = ShaclCoreShape.$Identifier || (ShaclCoreShape.$Identifier = {}));
+    function $toRdf(_shaclCoreShape, _parameters) {
+        switch (_shaclCoreShape.$type) {
+            case "ShaclCoreNodeShape":
+            case "ShaclmateNodeShape":
+                return ShaclCoreNodeShapeStatic.$toRdf(_shaclCoreShape, _parameters);
+            case "ShaclCorePropertyShape":
+            case "ShaclmatePropertyShape":
+                return ShaclCorePropertyShapeStatic.$toRdf(_shaclCoreShape, _parameters);
+            default:
+                _shaclCoreShape;
+                throw new Error("unrecognized type");
+        }
+    }
+    ShaclCoreShape.$toRdf = $toRdf;
 })(ShaclCoreShape || (ShaclCoreShape = {}));
 export var ShaclmateShape;
 (function (ShaclmateShape) {
-    function fromRdf({ ignoreRdfType, resource, ...context }) {
-        return ShaclmateNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+    function $fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclmateNodeShape.$fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf({
             ...context,
             resource,
         }));
     }
-    ShaclmateShape.fromRdf = fromRdf;
+    ShaclmateShape.$fromRdf = $fromRdf;
+    let $Identifier;
+    (function ($Identifier) {
+        function fromString(identifier) {
+            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
+                dataFactory,
+                identifier,
+            }));
+        }
+        $Identifier.fromString = fromString;
+        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+    })($Identifier = ShaclmateShape.$Identifier || (ShaclmateShape.$Identifier = {}));
+    function $toRdf(_shaclmateShape, _parameters) {
+        switch (_shaclmateShape.$type) {
+            case "ShaclmateNodeShape":
+                return ShaclmateNodeShape.$toRdf(_shaclmateShape, _parameters);
+            case "ShaclCorePropertyShape":
+            case "ShaclmatePropertyShape":
+                return ShaclCorePropertyShapeStatic.$toRdf(_shaclmateShape, _parameters);
+            default:
+                _shaclmateShape;
+                throw new Error("unrecognized type");
+        }
+    }
+    ShaclmateShape.$toRdf = $toRdf;
 })(ShaclmateShape || (ShaclmateShape = {}));
+export class $RdfjsDatasetObjectSet {
+    resourceSet;
+    constructor({ dataset }) {
+        this.resourceSet = new rdfjsResource.ResourceSet({ dataset });
+    }
+    async owlOntology(identifier) {
+        return this.owlOntologySync(identifier);
+    }
+    owlOntologySync(identifier) {
+        return this.owlOntologiesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async owlOntologyIdentifiers(query) {
+        return this.owlOntologyIdentifiersSync(query);
+    }
+    owlOntologyIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(OwlOntologyStatic, query);
+    }
+    async owlOntologies(query) {
+        return this.owlOntologiesSync(query);
+    }
+    owlOntologiesSync(query) {
+        return this.$objectsSync(OwlOntologyStatic, query);
+    }
+    async owlOntologiesCount(query) {
+        return this.owlOntologiesCountSync(query);
+    }
+    owlOntologiesCountSync(query) {
+        return this.$objectsCountSync(OwlOntologyStatic, query);
+    }
+    async shaclCoreNodeShape(identifier) {
+        return this.shaclCoreNodeShapeSync(identifier);
+    }
+    shaclCoreNodeShapeSync(identifier) {
+        return this.shaclCoreNodeShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclCoreNodeShapeIdentifiers(query) {
+        return this.shaclCoreNodeShapeIdentifiersSync(query);
+    }
+    shaclCoreNodeShapeIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclCoreNodeShapeStatic, query);
+    }
+    async shaclCoreNodeShapes(query) {
+        return this.shaclCoreNodeShapesSync(query);
+    }
+    shaclCoreNodeShapesSync(query) {
+        return this.$objectsSync(ShaclCoreNodeShapeStatic, query);
+    }
+    async shaclCoreNodeShapesCount(query) {
+        return this.shaclCoreNodeShapesCountSync(query);
+    }
+    shaclCoreNodeShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclCoreNodeShapeStatic, query);
+    }
+    async shaclCorePropertyGroup(identifier) {
+        return this.shaclCorePropertyGroupSync(identifier);
+    }
+    shaclCorePropertyGroupSync(identifier) {
+        return this.shaclCorePropertyGroupsSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclCorePropertyGroupIdentifiers(query) {
+        return this.shaclCorePropertyGroupIdentifiersSync(query);
+    }
+    shaclCorePropertyGroupIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclCorePropertyGroup, query);
+    }
+    async shaclCorePropertyGroups(query) {
+        return this.shaclCorePropertyGroupsSync(query);
+    }
+    shaclCorePropertyGroupsSync(query) {
+        return this.$objectsSync(ShaclCorePropertyGroup, query);
+    }
+    async shaclCorePropertyGroupsCount(query) {
+        return this.shaclCorePropertyGroupsCountSync(query);
+    }
+    shaclCorePropertyGroupsCountSync(query) {
+        return this.$objectsCountSync(ShaclCorePropertyGroup, query);
+    }
+    async shaclCorePropertyShape(identifier) {
+        return this.shaclCorePropertyShapeSync(identifier);
+    }
+    shaclCorePropertyShapeSync(identifier) {
+        return this.shaclCorePropertyShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclCorePropertyShapeIdentifiers(query) {
+        return this.shaclCorePropertyShapeIdentifiersSync(query);
+    }
+    shaclCorePropertyShapeIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclCorePropertyShapeStatic, query);
+    }
+    async shaclCorePropertyShapes(query) {
+        return this.shaclCorePropertyShapesSync(query);
+    }
+    shaclCorePropertyShapesSync(query) {
+        return this.$objectsSync(ShaclCorePropertyShapeStatic, query);
+    }
+    async shaclCorePropertyShapesCount(query) {
+        return this.shaclCorePropertyShapesCountSync(query);
+    }
+    shaclCorePropertyShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclCorePropertyShapeStatic, query);
+    }
+    async shaclmateNodeShape(identifier) {
+        return this.shaclmateNodeShapeSync(identifier);
+    }
+    shaclmateNodeShapeSync(identifier) {
+        return this.shaclmateNodeShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclmateNodeShapeIdentifiers(query) {
+        return this.shaclmateNodeShapeIdentifiersSync(query);
+    }
+    shaclmateNodeShapeIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclmateNodeShape, query);
+    }
+    async shaclmateNodeShapes(query) {
+        return this.shaclmateNodeShapesSync(query);
+    }
+    shaclmateNodeShapesSync(query) {
+        return this.$objectsSync(ShaclmateNodeShape, query);
+    }
+    async shaclmateNodeShapesCount(query) {
+        return this.shaclmateNodeShapesCountSync(query);
+    }
+    shaclmateNodeShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclmateNodeShape, query);
+    }
+    async shaclmateOntology(identifier) {
+        return this.shaclmateOntologySync(identifier);
+    }
+    shaclmateOntologySync(identifier) {
+        return this.shaclmateOntologiesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclmateOntologyIdentifiers(query) {
+        return this.shaclmateOntologyIdentifiersSync(query);
+    }
+    shaclmateOntologyIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclmateOntology, query);
+    }
+    async shaclmateOntologies(query) {
+        return this.shaclmateOntologiesSync(query);
+    }
+    shaclmateOntologiesSync(query) {
+        return this.$objectsSync(ShaclmateOntology, query);
+    }
+    async shaclmateOntologiesCount(query) {
+        return this.shaclmateOntologiesCountSync(query);
+    }
+    shaclmateOntologiesCountSync(query) {
+        return this.$objectsCountSync(ShaclmateOntology, query);
+    }
+    async shaclmatePropertyShape(identifier) {
+        return this.shaclmatePropertyShapeSync(identifier);
+    }
+    shaclmatePropertyShapeSync(identifier) {
+        return this.shaclmatePropertyShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclmatePropertyShapeIdentifiers(query) {
+        return this.shaclmatePropertyShapeIdentifiersSync(query);
+    }
+    shaclmatePropertyShapeIdentifiersSync(query) {
+        return this.$objectIdentifiersSync(ShaclmatePropertyShape, query);
+    }
+    async shaclmatePropertyShapes(query) {
+        return this.shaclmatePropertyShapesSync(query);
+    }
+    shaclmatePropertyShapesSync(query) {
+        return this.$objectsSync(ShaclmatePropertyShape, query);
+    }
+    async shaclmatePropertyShapesCount(query) {
+        return this.shaclmatePropertyShapesCountSync(query);
+    }
+    shaclmatePropertyShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclmatePropertyShape, query);
+    }
+    async shaclCoreShape(identifier) {
+        return this.shaclCoreShapeSync(identifier);
+    }
+    shaclCoreShapeSync(identifier) {
+        return this.shaclCoreShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclCoreShapeIdentifiers(query) {
+        return this.shaclCoreShapeIdentifiersSync(query);
+    }
+    shaclCoreShapeIdentifiersSync(query) {
+        return this.$objectUnionIdentifiersSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+    }
+    async shaclCoreShapes(query) {
+        return this.shaclCoreShapesSync(query);
+    }
+    shaclCoreShapesSync(query) {
+        return this.$objectUnionsSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+    }
+    async shaclCoreShapesCount(query) {
+        return this.shaclCoreShapesCountSync(query);
+    }
+    shaclCoreShapesCountSync(query) {
+        return this.$objectUnionsCountSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+    }
+    async shaclmateShape(identifier) {
+        return this.shaclmateShapeSync(identifier);
+    }
+    shaclmateShapeSync(identifier) {
+        return this.shaclmateShapesSync({
+            where: { identifiers: [identifier], type: "identifiers" },
+        }).map((objects) => objects[0]);
+    }
+    async shaclmateShapeIdentifiers(query) {
+        return this.shaclmateShapeIdentifiersSync(query);
+    }
+    shaclmateShapeIdentifiersSync(query) {
+        return this.$objectUnionIdentifiersSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+    }
+    async shaclmateShapes(query) {
+        return this.shaclmateShapesSync(query);
+    }
+    shaclmateShapesSync(query) {
+        return this.$objectUnionsSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+    }
+    async shaclmateShapesCount(query) {
+        return this.shaclmateShapesCountSync(query);
+    }
+    shaclmateShapesCountSync(query) {
+        return this.$objectUnionsCountSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+    }
+    $objectIdentifiersSync(objectType, query) {
+        return this.$objectsSync(objectType, query).map((objects) => objects.map((object) => object.$identifier));
+    }
+    $objectsSync(objectType, query) {
+        const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+        if (limit <= 0) {
+            return purify.Either.of([]);
+        }
+        let offset = query?.offset ?? 0;
+        if (offset < 0) {
+            offset = 0;
+        }
+        if (query?.where) {
+            // Assign identifiers in each case block so the compiler will catch missing cases.
+            let identifiers;
+            switch (query.where.type) {
+                case "identifiers": {
+                    identifiers = query.where.identifiers.slice(offset, offset + limit);
+                    break;
+                }
+                case "triple-objects": {
+                    let identifierI = 0;
+                    identifiers = [];
+                    for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
+                        if (quad.object.termType === "BlankNode" ||
+                            quad.object.termType === "NamedNode") {
+                            if (++identifierI >= offset) {
+                                identifiers.push(quad.object);
+                                if (identifiers.length === limit) {
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            return purify.Left(new Error(`subject=${query.where.subject.value} predicate=${query.where.predicate.value} pattern matches non-identifier (${quad.object.termType}) triple`));
+                        }
+                    }
+                    break;
+                }
+            }
+            const objects = [];
+            for (const identifier of identifiers) {
+                const either = objectType.$fromRdf({
+                    resource: this.resourceSet.resource(identifier),
+                });
+                if (either.isLeft()) {
+                    return either;
+                }
+                objects.push(either.unsafeCoerce());
+            }
+            return purify.Either.of(objects);
+        }
+        if (!objectType.$fromRdfType) {
+            return purify.Either.of([]);
+        }
+        const resources = [
+            ...this.resourceSet.instancesOf(objectType.$fromRdfType),
+        ];
+        // Sort resources by identifier so limit and offset are deterministic
+        resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
+        const objects = [];
+        let objectI = 0;
+        for (const resource of resources) {
+            const either = objectType.$fromRdf({ resource });
+            if (either.isLeft()) {
+                return either;
+            }
+            if (objectI++ >= offset) {
+                objects.push(either.unsafeCoerce());
+                if (objects.length === limit) {
+                    return purify.Either.of(objects);
+                }
+            }
+        }
+        return purify.Either.of(objects);
+    }
+    $objectsCountSync(objectType, query) {
+        return this.$objectsSync(objectType, query).map((objects) => objects.length);
+    }
+    $objectUnionIdentifiersSync(objectTypes, query) {
+        return this.$objectUnionsSync(objectTypes, query).map((objects) => objects.map((object) => object.$identifier));
+    }
+    $objectUnionsSync(objectTypes, query) {
+        const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+        if (limit <= 0) {
+            return purify.Either.of([]);
+        }
+        let offset = query?.offset ?? 0;
+        if (offset < 0) {
+            offset = 0;
+        }
+        if (query?.where) {
+            // Assign identifiers in each case block so the compiler will catch missing cases.
+            let identifiers;
+            switch (query.where.type) {
+                case "identifiers": {
+                    identifiers = query.where.identifiers.slice(offset, offset + limit);
+                    break;
+                }
+                case "triple-objects": {
+                    let identifierI = 0;
+                    identifiers = [];
+                    for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
+                        if (quad.object.termType === "BlankNode" ||
+                            quad.object.termType === "NamedNode") {
+                            if (++identifierI >= offset) {
+                                identifiers.push(quad.object);
+                                if (identifiers.length === limit) {
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            return purify.Left(new Error(`subject=${query.where.subject.value} predicate=${query.where.predicate.value} pattern matches non-identifier (${quad.object.termType}) triple`));
+                        }
+                    }
+                    break;
+                }
+            }
+            const objects = [];
+            for (const identifier of identifiers) {
+                const resource = this.resourceSet.resource(identifier);
+                const lefts = [];
+                for (const objectType of objectTypes) {
+                    const either = objectType.$fromRdf({ resource });
+                    if (either.isRight()) {
+                        objects.push(either.unsafeCoerce());
+                        break;
+                    }
+                    lefts.push(either);
+                }
+                // Doesn't appear to belong to any of the known object types, just assume the first
+                if (lefts.length === objectTypes.length) {
+                    return lefts[0];
+                }
+            }
+            return purify.Either.of(objects);
+        }
+        const resources = [];
+        for (const objectType of objectTypes) {
+            if (!objectType.$fromRdfType) {
+                continue;
+            }
+            for (const resource of this.resourceSet.instancesOf(objectType.$fromRdfType)) {
+                resources.push({ objectType, resource });
+            }
+        }
+        // Sort resources by identifier so limit and offset are deterministic
+        resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
+        let objectI = 0;
+        const objects = [];
+        for (const { objectType, resource } of resources) {
+            const either = objectType.$fromRdf({ resource });
+            if (either.isLeft()) {
+                return either;
+            }
+            if (objectI++ >= offset) {
+                objects.push(either.unsafeCoerce());
+                if (objects.length === limit) {
+                    return purify.Either.of(objects);
+                }
+            }
+        }
+        return purify.Either.of(objects);
+    }
+    $objectUnionsCountSync(objectTypes, query) {
+        return this.$objectUnionIdentifiersSync(objectTypes, query).map((objects) => objects.length);
+    }
+}
 //# sourceMappingURL=generated.js.map