@shaclmate/shacl-ast 2.0.20 → 2.0.23

package/dist/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 = {}));
+    BaseShaclCoreShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        const { ignoreRdfType: _, ...otherParameters } = parameters;
+        return ShaclCoreNodeShape.$fromRdf(otherParameters).altLazy(() => ShaclCorePropertyShape.$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 ShaclCorePropertyShape;
 (function (ShaclCorePropertyShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    ShaclCorePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    ShaclCorePropertyShape.$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"),
-            }));
+        if ($super0Either.isLeft()) {
+            return $super0Either;
         }
-        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 })
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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: ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$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,227 +840,683 @@ export var ShaclCorePropertyShape;
             uniqueLang,
         });
     }
-    ShaclCorePropertyShape._propertiesFromRdf = _propertiesFromRdf;
-    function fromRdf(parameters) {
-        return ShaclCorePropertyShape._propertiesFromRdf(parameters);
+    ShaclCorePropertyShape.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclCorePropertyShape.$propertiesFromRdf(parameters);
     }
-    ShaclCorePropertyShape.fromRdf = fromRdf;
-    ShaclCorePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    ShaclCorePropertyShape.$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(ShaclCorePropertyShape.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
+        _resource.add(ShaclCorePropertyShape.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
+        _resource.add(ShaclCorePropertyShape.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
+        _resource.add(ShaclCorePropertyShape.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
+        _resource.add(ShaclCorePropertyShape.$properties.order["identifier"], _shaclCorePropertyShape.order);
+        _resource.add(ShaclCorePropertyShape.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+            mutateGraph: mutateGraph,
+            resourceSet: resourceSet,
+        }));
+        _resource.add(ShaclCorePropertyShape.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
+        return _resource;
+    }
+    ShaclCorePropertyShape.$toRdf = $toRdf;
+    ShaclCorePropertyShape.$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"),
+        },
+    };
 })(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
 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;
+    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.fromRdf = fromRdf;
-    ShaclCorePropertyGroup.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
+    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 ShaclCoreNodeShape;
 (function (ShaclCoreNodeShape) {
-    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    ShaclCoreNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
+    ShaclCoreNodeShape.$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"),
-            }));
+        if ($super0Either.isLeft()) {
+            return $super0Either;
         }
-        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,
-        })
+        const $super0 = $super0Either.unsafeCoerce();
+        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCoreNodeShape.$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(ShaclCoreNodeShape.$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(ShaclCoreNodeShape.$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(ShaclCoreNodeShape.$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);
+    ShaclCoreNodeShape.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return ShaclCoreNodeShape.$propertiesFromRdf(parameters);
+    }
+    ShaclCoreNodeShape.$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(ShaclCoreNodeShape.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
+        _resource.add(ShaclCoreNodeShape.$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(ShaclCoreNodeShape.$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.$toRdf = $toRdf;
+    ShaclCoreNodeShape.$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"),
+        },
+    };
 })(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
 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"),
+    OwlOntology.$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 = OwlOntology.$Identifier || (OwlOntology.$Identifier = {}));
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    // @ts-ignore
+    ...$context }) {
+        if (!$ignoreRdfType && !$resource.isInstanceOf(OwlOntology.$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(OwlOntology.$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);
+    OwlOntology.$propertiesFromRdf = $propertiesFromRdf;
+    function $fromRdf(parameters) {
+        return OwlOntology.$propertiesFromRdf(parameters);
     }
-    OwlOntology.fromRdf = fromRdf;
-    OwlOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    OwlOntology.$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(OwlOntology.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
+        return _resource;
+    }
+    OwlOntology.$toRdf = $toRdf;
+    OwlOntology.$properties = {
+        labels: {
+            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+        },
+    };
 })(OwlOntology || (OwlOntology = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
-    function fromRdf({ ignoreRdfType, resource, ...context }) {
-        return ShaclCoreNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+    function $fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclCoreNodeShape.$fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.$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":
+                return ShaclCoreNodeShape.$toRdf(_shaclCoreShape, _parameters);
+            case "ShaclCorePropertyShape":
+                return ShaclCorePropertyShape.$toRdf(_shaclCoreShape, _parameters);
+            default:
+                _shaclCoreShape;
+                throw new Error("unrecognized type");
+        }
+    }
+    ShaclCoreShape.$toRdf = $toRdf;
 })(ShaclCoreShape || (ShaclCoreShape = {}));
+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(OwlOntology, query);
+    }
+    async owlOntologies(query) {
+        return this.owlOntologiesSync(query);
+    }
+    owlOntologiesSync(query) {
+        return this.$objectsSync(OwlOntology, query);
+    }
+    async owlOntologiesCount(query) {
+        return this.owlOntologiesCountSync(query);
+    }
+    owlOntologiesCountSync(query) {
+        return this.$objectsCountSync(OwlOntology, 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(ShaclCoreNodeShape, query);
+    }
+    async shaclCoreNodeShapes(query) {
+        return this.shaclCoreNodeShapesSync(query);
+    }
+    shaclCoreNodeShapesSync(query) {
+        return this.$objectsSync(ShaclCoreNodeShape, query);
+    }
+    async shaclCoreNodeShapesCount(query) {
+        return this.shaclCoreNodeShapesCountSync(query);
+    }
+    shaclCoreNodeShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclCoreNodeShape, 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(ShaclCorePropertyShape, query);
+    }
+    async shaclCorePropertyShapes(query) {
+        return this.shaclCorePropertyShapesSync(query);
+    }
+    shaclCorePropertyShapesSync(query) {
+        return this.$objectsSync(ShaclCorePropertyShape, query);
+    }
+    async shaclCorePropertyShapesCount(query) {
+        return this.shaclCorePropertyShapesCountSync(query);
+    }
+    shaclCorePropertyShapesCountSync(query) {
+        return this.$objectsCountSync(ShaclCorePropertyShape, 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([ShaclCoreNodeShape, ShaclCorePropertyShape], query);
+    }
+    async shaclCoreShapes(query) {
+        return this.shaclCoreShapesSync(query);
+    }
+    shaclCoreShapesSync(query) {
+        return this.$objectUnionsSync([ShaclCoreNodeShape, ShaclCorePropertyShape], query);
+    }
+    async shaclCoreShapesCount(query) {
+        return this.shaclCoreShapesCountSync(query);
+    }
+    shaclCoreShapesCountSync(query) {
+        return this.$objectUnionsCountSync([ShaclCoreNodeShape, ShaclCorePropertyShape], 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