@shaclmate/shacl-ast 3.0.4 → 4.0.1

package/dist/generated.js

@@ -1,10 +1,169 @@
-import { StoreFactory as _DatasetFactory } from "n3";
-const datasetFactory = new _DatasetFactory();
-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 $RdfVocabularies;
+import dataFactory from "@rdfjs/data-model";
+import datasetFactory from "@rdfjs/dataset";
+import { Either, Left, Maybe, Right } from "purify-ts";
+import { LiteralFactory, PropertyPath, Resource, ResourceSet, } from "rdfjs-resource";
+function $filterArray(filterItem) {
+    return (filter, values) => {
+        for (const value of values) {
+            if (!filterItem(filter, value)) {
+                return false;
+            }
+        }
+        if (filter.$maxCount !== undefined && values.length > filter.$maxCount) {
+            return false;
+        }
+        if (filter.$minCount !== undefined && values.length < filter.$minCount) {
+            return false;
+        }
+        return true;
+    };
+}
+function $filterBoolean(filter, value) {
+    if (filter.value !== undefined && value !== filter.value) {
+        return false;
+    }
+    return true;
+}
+function $filterIdentifier(filter, value) {
+    if (filter.in !== undefined &&
+        !filter.in.some((inValue) => inValue.equals(value))) {
+        return false;
+    }
+    if (filter.type !== undefined && value.termType !== filter.type) {
+        return false;
+    }
+    return true;
+}
+function $filterIri(filter, value) {
+    if (filter.in !== undefined &&
+        !filter.in.some((inValue) => inValue.equals(value))) {
+        return false;
+    }
+    return true;
+}
+function $filterLiteral(filter, value) {
+    return $filterTerm(filter, value);
+}
+function $filterMaybe(filterItem) {
+    return (filter, value) => {
+        if (filter !== null) {
+            if (value.isNothing()) {
+                return false;
+            }
+            if (!filterItem(filter, value.extract())) {
+                return false;
+            }
+        }
+        else {
+            if (value.isJust()) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+function $filterNumeric(filter, value) {
+    if (filter.in !== undefined &&
+        !filter.in.some((inValue) => inValue === value)) {
+        return false;
+    }
+    if (filter.maxExclusive !== undefined && value >= filter.maxExclusive) {
+        return false;
+    }
+    if (filter.maxInclusive !== undefined && value > filter.maxInclusive) {
+        return false;
+    }
+    if (filter.minExclusive !== undefined && value <= filter.minExclusive) {
+        return false;
+    }
+    if (filter.minInclusive !== undefined && value < filter.minInclusive) {
+        return false;
+    }
+    return true;
+}
+function $filterString(filter, value) {
+    if (filter.in !== undefined &&
+        !filter.in.some((inValue) => inValue === value)) {
+        return false;
+    }
+    if (filter.maxLength !== undefined && value.length > filter.maxLength) {
+        return false;
+    }
+    if (filter.minLength !== undefined && value.length < filter.minLength) {
+        return false;
+    }
+    return true;
+}
+function $filterTerm(filter, value) {
+    if (filter.datatypeIn !== undefined &&
+        (value.termType !== "Literal" ||
+            !filter.datatypeIn.some((inDatatype) => inDatatype.equals(value.datatype)))) {
+        return false;
+    }
+    if (filter.in !== undefined &&
+        !filter.in.some((inTerm) => inTerm.equals(value))) {
+        return false;
+    }
+    if (filter.languageIn !== undefined &&
+        (value.termType !== "Literal" ||
+            !filter.languageIn.some((inLanguage) => inLanguage === value.language))) {
+        return false;
+    }
+    if (filter.typeIn !== undefined &&
+        !filter.typeIn.some((inType) => inType === value.termType)) {
+        return false;
+    }
+    return true;
+}
+function $fromRdfPreferredLanguages(values, preferredLanguages) {
+    if (!preferredLanguages || preferredLanguages.length === 0) {
+        return Right(values);
+    }
+    // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+    // Within a preferredLanguage the literals may be in any order.
+    const filteredValues = [];
+    for (const preferredLanguage of preferredLanguages) {
+        for (const value of values) {
+            value.toLiteral().ifRight((literal) => {
+                if (literal.language === preferredLanguage) {
+                    filteredValues.push(value);
+                }
+            });
+        }
+    }
+    return Right(Resource.Values.fromArray({
+        focusResource: values.focusResource,
+        propertyPath: values.propertyPath,
+        values: filteredValues,
+    }));
+}
+function $identifierFromString(identifier) {
+    return Either.encase(() => Resource.Identifier.fromString({ dataFactory, identifier }));
+}
+class $IdentifierSet {
+    blankNodeValues = new Set();
+    namedNodeValues = new Set();
+    add(identifier) {
+        switch (identifier.termType) {
+            case "BlankNode":
+                this.blankNodeValues.add(identifier.value);
+                return this;
+            case "NamedNode":
+                this.namedNodeValues.add(identifier.value);
+                return this;
+        }
+    }
+    has(identifier) {
+        switch (identifier.termType) {
+            case "BlankNode":
+                return this.blankNodeValues.has(identifier.value);
+            case "NamedNode":
+                return this.namedNodeValues.has(identifier.value);
+        }
+    }
+}
+const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
+var $RdfVocabularies;
 (function ($RdfVocabularies) {
     let rdf;
     (function (rdf) {
@@ -21,723 +180,617 @@ export var $RdfVocabularies;
     let xsd;
     (function (xsd) {
         xsd.boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
+        xsd.byte = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#byte");
         xsd.date = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date");
         xsd.dateTime = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
+        xsd.decimal = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal");
+        xsd.double = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double");
+        xsd.float = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#float");
+        xsd.int = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int");
         xsd.integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
+        xsd.long = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#long");
+        xsd.negativeInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger");
+        xsd.nonNegativeInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
+        xsd.nonPositiveInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger");
+        xsd.positiveInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger");
+        xsd.short = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#short");
+        xsd.string = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string");
+        xsd.unsignedByte = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte");
+        xsd.unsignedInt = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt");
+        xsd.unsignedLong = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong");
+        xsd.unsignedShort = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort");
     })(xsd = $RdfVocabularies.xsd || ($RdfVocabularies.xsd = {}));
 })($RdfVocabularies || ($RdfVocabularies = {}));
+function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }) {
+    return typeFromRdf(Right(resource.values(propertySchema.path, { graph, unique: true }))).chain((values) => values.head());
+}
 export var BaseShaclCoreShapeStatic;
 (function (BaseShaclCoreShapeStatic) {
-    let $Identifier;
-    (function ($Identifier) {
-        function fromString(identifier) {
-            return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({
-                dataFactory,
-                identifier,
-            }));
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
         }
-        $Identifier.fromString = fromString;
-        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
-    })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
-    function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
-        if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        if (filter.and !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.and, value.and)) {
+            return false;
         }
-        return ShaclCoreNodeShape.$fromRdf(resource, {
-            ...context,
-            ignoreRdfType: false,
-            objectSet,
-        }).altLazy(() => ShaclCorePropertyShape.$fromRdf(resource, {
-            ...context,
-            ignoreRdfType: false,
-            objectSet,
-        }));
-    }
-    BaseShaclCoreShapeStatic.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
-    // @ts-ignore
-    ...$context }) {
-        const $identifier = $resource.identifier;
-        const _andEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.and["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: BaseShaclCoreShapeStatic.$properties.and["identifier"],
-            subject: $resource,
-        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.and["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_andEither.isLeft()) {
-            return _andEither;
-        }
-        const and = _andEither.unsafeCoerce();
-        const _classesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.classes["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toIri()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.classes["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_classesEither.isLeft()) {
-            return _classesEither;
-        }
-        const classes = _classesEither.unsafeCoerce();
-        const _commentsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.comments["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.comments["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.comments["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_commentsEither.isLeft()) {
-            return _commentsEither;
-        }
-        const comments = _commentsEither.unsafeCoerce();
-        const _datatypeEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toIri()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.datatype["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_datatypeEither.isLeft()) {
-            return _datatypeEither;
-        }
-        const datatype = _datatypeEither.unsafeCoerce();
-        const _deactivatedEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toBoolean()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.deactivated["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_deactivatedEither.isLeft()) {
-            return _deactivatedEither;
-        }
-        const deactivated = _deactivatedEither.unsafeCoerce();
-        const _flagsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.flags["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.flags["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toString()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.flags["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_flagsEither.isLeft()) {
-            return _flagsEither;
-        }
-        const flags = _flagsEither.unsafeCoerce();
-        const _hasValuesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((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"],
-                    }));
-            }
-        })))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.hasValues["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_hasValuesEither.isLeft()) {
-            return _hasValuesEither;
-        }
-        const hasValues = _hasValuesEither.unsafeCoerce();
-        const _in_Either = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.in_["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: BaseShaclCoreShapeStatic.$properties.in_["identifier"],
-            subject: $resource,
-        })).chain((values) => values.chainMap((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((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.in_["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_in_Either.isLeft()) {
-            return _in_Either;
+        if (filter.classes !== undefined &&
+            !$filterArray($filterIri)(filter.classes, value.classes)) {
+            return false;
         }
-        const in_ = _in_Either.unsafeCoerce();
-        const _isDefinedByEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_isDefinedByEither.isLeft()) {
-            return _isDefinedByEither;
-        }
-        const isDefinedBy = _isDefinedByEither.unsafeCoerce();
-        const _labelsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.labels["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.labels["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.labels["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_labelsEither.isLeft()) {
-            return _labelsEither;
-        }
-        const labels = _labelsEither.unsafeCoerce();
-        const _languageInEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toString()))))
-            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_languageInEither.isLeft()) {
-            return _languageInEither;
-        }
-        const languageIn = _languageInEither.unsafeCoerce();
-        const _maxCountEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toNumber()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.maxCount["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_maxCountEither.isLeft()) {
-            return _maxCountEither;
+        if (filter.comments !== undefined &&
+            !$filterArray($filterString)(filter.comments, value.comments)) {
+            return false;
         }
-        const maxCount = _maxCountEither.unsafeCoerce();
-        const _maxExclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_maxExclusiveEither.isLeft()) {
-            return _maxExclusiveEither;
+        if (filter.datatype !== undefined &&
+            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
+            return false;
         }
-        const maxExclusive = _maxExclusiveEither.unsafeCoerce();
-        const _maxInclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_maxInclusiveEither.isLeft()) {
-            return _maxInclusiveEither;
-        }
-        const maxInclusive = _maxInclusiveEither.unsafeCoerce();
-        const _maxLengthEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toNumber()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.maxLength["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_maxLengthEither.isLeft()) {
-            return _maxLengthEither;
-        }
-        const maxLength = _maxLengthEither.unsafeCoerce();
-        const _minCountEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toNumber()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.minCount["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_minCountEither.isLeft()) {
-            return _minCountEither;
+        if (filter.deactivated !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
+            return false;
         }
-        const minCount = _minCountEither.unsafeCoerce();
-        const _minExclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_minExclusiveEither.isLeft()) {
-            return _minExclusiveEither;
+        if (filter.flags !== undefined &&
+            !$filterArray($filterString)(filter.flags, value.flags)) {
+            return false;
         }
-        const minExclusive = _minExclusiveEither.unsafeCoerce();
-        const _minInclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_minInclusiveEither.isLeft()) {
-            return _minInclusiveEither;
-        }
-        const minInclusive = _minInclusiveEither.unsafeCoerce();
-        const _minLengthEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toNumber()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.minLength["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_minLengthEither.isLeft()) {
-            return _minLengthEither;
-        }
-        const minLength = _minLengthEither.unsafeCoerce();
-        const _nodeKindEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
-            switch (iri.value) {
-                case "http://www.w3.org/ns/shacl#BlankNode":
-                    return purify.Either.of(iri);
-                case "http://www.w3.org/ns/shacl#BlankNodeOrIRI":
-                    return purify.Either.of(iri);
-                case "http://www.w3.org/ns/shacl#BlankNodeOrLiteral":
-                    return purify.Either.of(iri);
-                case "http://www.w3.org/ns/shacl#IRI":
-                    return purify.Either.of(iri);
-                case "http://www.w3.org/ns/shacl#IRIOrLiteral":
-                    return purify.Either.of(iri);
-                case "http://www.w3.org/ns/shacl#Literal":
-                    return purify.Either.of(iri);
-                default:
-                    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: BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"],
-                    }));
-            }
-        })))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_nodeKindEither.isLeft()) {
-            return _nodeKindEither;
+        if (filter.hasValues !== undefined &&
+            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
+            return false;
         }
-        const nodeKind = _nodeKindEither.unsafeCoerce();
-        const _nodesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.nodes["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_nodesEither.isLeft()) {
-            return _nodesEither;
+        if (filter.in_ !== undefined &&
+            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
+            return false;
+        }
+        if (filter.isDefinedBy !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
+            return false;
+        }
+        if (filter.labels !== undefined &&
+            !$filterArray($filterString)(filter.labels, value.labels)) {
+            return false;
+        }
+        if (filter.languageIn !== undefined &&
+            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
+            return false;
+        }
+        if (filter.maxCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
+            return false;
+        }
+        if (filter.maxExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
+            return false;
+        }
+        if (filter.maxInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
+            return false;
+        }
+        if (filter.maxLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
+            return false;
+        }
+        if (filter.minCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
+            return false;
+        }
+        if (filter.minExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
+            return false;
+        }
+        if (filter.minInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
+            return false;
+        }
+        if (filter.minLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
+            return false;
+        }
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+            return false;
+        }
+        if (filter.nodes !== undefined &&
+            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
+            return false;
+        }
+        if (filter.not !== undefined &&
+            !$filterArray($filterIdentifier)(filter.not, value.not)) {
+            return false;
+        }
+        if (filter.or !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
+            return false;
+        }
+        if (filter.patterns !== undefined &&
+            !$filterArray($filterString)(filter.patterns, value.patterns)) {
+            return false;
+        }
+        if (filter.xone !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            return false;
+        }
+        return true;
+    }
+    BaseShaclCoreShapeStatic.$filter = $filter;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
+    function isBaseShaclCoreShape(object) {
+        switch (object.$type) {
+            case "ShaclCoreNodeShape":
+            case "ShaclCorePropertyShape":
+                return true;
+            default:
+                return false;
         }
-        const nodes = _nodesEither.unsafeCoerce();
-        const _notEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.not["identifier"], { unique: true }))
+    }
+    BaseShaclCoreShapeStatic.isBaseShaclCoreShape = isBaseShaclCoreShape;
+    function $propertiesFromRdf($parameters) {
+        return Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $parameters.resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $parameters.resource.identifier,
+        }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.not["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_notEither.isLeft()) {
-            return _notEither;
-        }
-        const not = _notEither.unsafeCoerce();
-        const _orEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.or["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: BaseShaclCoreShapeStatic.$properties.or["identifier"],
-            subject: $resource,
-        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.or["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_orEither.isLeft()) {
-            return _orEither;
-        }
-        const or = _orEither.unsafeCoerce();
-        const _patternsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
+            .chain((values) => values.head())
+            .chain(($identifier) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.and,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.and.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.and.path,
+                value: valuesArray,
+            })),
+        }).chain((and) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.classes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.classes.path,
+                value: valuesArray,
+            })),
+        }).chain((classes) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.comments,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.comments
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((comments) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.datatype,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema.properties
+                        .datatype.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((datatype) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.deactivated,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema.properties
+                        .deactivated.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((deactivated) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.flags,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.flags
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((flags) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.hasValues,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $parameters.resource,
+                            propertyPath: BaseShaclCoreShapeStatic.$schema
+                                .properties.hasValues.path,
+                        }));
                 }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
+            })))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema.properties
+                    .hasValues.path,
+                value: valuesArray,
+            })),
+        }).chain((hasValues) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.in_,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema
+                    .properties.in_.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $parameters.resource,
+                            propertyPath: BaseShaclCoreShapeStatic
+                                .$schema.properties.in_
+                                .path,
+                        }));
                 }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: BaseShaclCoreShapeStatic.$properties.patterns["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toString()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.patterns["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_patternsEither.isLeft()) {
-            return _patternsEither;
-        }
-        const patterns = _patternsEither.unsafeCoerce();
-        const _xoneEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.xone["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: BaseShaclCoreShapeStatic.$properties.xone["identifier"],
-            subject: $resource,
-        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: BaseShaclCoreShapeStatic.$properties.xone["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_xoneEither.isLeft()) {
-            return _xoneEither;
-        }
-        const xone = _xoneEither.unsafeCoerce();
-        return purify.Either.of({
+            })))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema
+                        .properties.in_.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((in_) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.isDefinedBy,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema
+                        .properties.isDefinedBy.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((isDefinedBy) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.labels,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema
+                    .properties.labels.path,
+                value: valuesArray,
+            })),
+        }).chain((labels) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.languageIn,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: $parameters.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic.$schema
+                    .properties.languageIn.path,
+                values: valueList.toArray(),
+            }))
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema
+                        .properties.languageIn.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((languageIn) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxCount,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toInt()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema
+                        .properties.maxCount.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxCount) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxExclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toLiteral()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic.$schema
+                        .properties.maxExclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxExclusive) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxInclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toLiteral()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema.properties
+                        .maxInclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxInclusive) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxLength,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toInt()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema.properties
+                        .maxLength.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxLength) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minCount,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toInt()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema.properties
+                        .minCount.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minCount) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minExclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toLiteral()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema.properties
+                        .minExclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minExclusive) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minInclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toLiteral()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema.properties
+                        .minInclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minInclusive) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minLength,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toInt()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema
+                        .properties
+                        .minLength.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minLength) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.nodeKind,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri([
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+            ])))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: BaseShaclCoreShapeStatic
+                        .$schema
+                        .properties
+                        .nodeKind.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((nodeKind) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.nodes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .nodes.path,
+                value: valuesArray,
+            })),
+        }).chain((nodes) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.not,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .not.path,
+                value: valuesArray,
+            })),
+        }).chain((not) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.or,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: $parameters.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .or
+                    .path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .or.path,
+                value: valuesArray,
+            })),
+        }).chain((or) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties
+                .patterns,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .patterns
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((patterns) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: BaseShaclCoreShapeStatic.$schema.properties
+                .xone,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: $parameters.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .xone
+                    .path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: BaseShaclCoreShapeStatic
+                    .$schema
+                    .properties
+                    .xone
+                    .path,
+                value: valuesArray,
+            })),
+        }).map((xone) => ({
             $identifier,
             and,
             classes,
@@ -764,235 +817,474 @@ export var BaseShaclCoreShapeStatic;
             or,
             patterns,
             xone,
-        });
+        })))))))))))))))))))))))))));
     }
     BaseShaclCoreShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
     function $toRdf(_baseShaclCoreShape, options) {
-        const mutateGraph = options?.mutateGraph;
         const resourceSet = options?.resourceSet ??
-            new rdfjsResource.MutableResourceSet({
-                dataFactory,
-                dataset: datasetFactory.dataset(),
-            });
-        const resource = resourceSet.mutableResource(_baseShaclCoreShape.$identifier, { mutateGraph });
-        resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], ..._baseShaclCoreShape.and.flatMap((item) => [
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_baseShaclCoreShape.$identifier);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _baseShaclCoreShape.and.flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], ..._baseShaclCoreShape.classes.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.comments["identifier"], ..._baseShaclCoreShape.comments.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], ..._baseShaclCoreShape.datatype.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], ..._baseShaclCoreShape.deactivated.toList().flat());
-        resource.add(BaseShaclCoreShapeStatic.$properties.flags["identifier"], ..._baseShaclCoreShape.flags.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], ..._baseShaclCoreShape.hasValues.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.in_["identifier"], ..._baseShaclCoreShape.in_.toList().flatMap((value) => [
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), _baseShaclCoreShape.classes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _baseShaclCoreShape.comments.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), _baseShaclCoreShape.datatype.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), _baseShaclCoreShape.deactivated
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), _baseShaclCoreShape.flags.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), _baseShaclCoreShape.hasValues.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), _baseShaclCoreShape.in_.toList().flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], ..._baseShaclCoreShape.isDefinedBy.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], ..._baseShaclCoreShape.labels.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], ..._baseShaclCoreShape.languageIn.toList().flatMap((value) => [
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), _baseShaclCoreShape.isDefinedBy.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _baseShaclCoreShape.labels.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), _baseShaclCoreShape.languageIn.toList().flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], ..._baseShaclCoreShape.maxCount.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], ..._baseShaclCoreShape.maxExclusive.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], ..._baseShaclCoreShape.maxInclusive.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], ..._baseShaclCoreShape.maxLength.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], ..._baseShaclCoreShape.minCount.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], ..._baseShaclCoreShape.minExclusive.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], ..._baseShaclCoreShape.minInclusive.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], ..._baseShaclCoreShape.minLength.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], ..._baseShaclCoreShape.nodeKind.toList());
-        resource.add(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], ..._baseShaclCoreShape.nodes.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.not["identifier"], ..._baseShaclCoreShape.not.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.or["identifier"], ..._baseShaclCoreShape.or.flatMap((item) => [
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), _baseShaclCoreShape.maxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), _baseShaclCoreShape.maxExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), _baseShaclCoreShape.maxInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), _baseShaclCoreShape.maxLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), _baseShaclCoreShape.minCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), _baseShaclCoreShape.minExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), _baseShaclCoreShape.minInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), _baseShaclCoreShape.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _baseShaclCoreShape.nodeKind.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _baseShaclCoreShape.nodes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _baseShaclCoreShape.not.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _baseShaclCoreShape.or.flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], ..._baseShaclCoreShape.patterns.flatMap((item) => [item]));
-        resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], ..._baseShaclCoreShape.xone.flatMap((item) => [
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _baseShaclCoreShape.patterns.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _baseShaclCoreShape.xone.flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
+        ]), options?.graph);
         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.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "TypeDiscriminant",
+                type: () => ({
+                    descendantValues: ["ShaclCoreNodeShape", "ShaclCorePropertyShape"],
+                    kind: "TypeDiscriminant",
+                }),
+            },
+            and: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+            },
+            classes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+            },
+            comments: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            datatype: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+            },
+            deactivated: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+            },
+            flags: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+            },
+            hasValues: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Term" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+            },
+            in_: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Term" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+            languageIn: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "String" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+            },
+            maxCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+            },
+            maxLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+            },
+            minCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+            },
+            minExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+            },
+            minInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+            },
+            minLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+            },
+            nodeKind: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+            },
+            nodes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
+            not: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+            },
+            or: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+            },
+            patterns: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+            },
+            xone: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+            },
         },
     };
 })(BaseShaclCoreShapeStatic || (BaseShaclCoreShapeStatic = {}));
 export var ShaclCorePropertyShape;
 (function (ShaclCorePropertyShape) {
+    function $filter(filter, value) {
+        if (!BaseShaclCoreShapeStatic.$filter(filter, value)) {
+            return false;
+        }
+        if (filter.defaultValue !== undefined &&
+            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
+            return false;
+        }
+        if (filter.descriptions !== undefined &&
+            !$filterArray($filterString)(filter.descriptions, value.descriptions)) {
+            return false;
+        }
+        if (filter.groups !== undefined &&
+            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
+            return false;
+        }
+        if (filter.names !== undefined &&
+            !$filterArray($filterString)(filter.names, value.names)) {
+            return false;
+        }
+        if (filter.order !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
+            return false;
+        }
+        if (filter.path !== undefined &&
+            !PropertyPath.$filter(filter.path, value.path)) {
+            return false;
+        }
+        if (filter.uniqueLang !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
+            return false;
+        }
+        return true;
+    }
+    ShaclCorePropertyShape.$filter = $filter;
     ShaclCorePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
-    ShaclCorePropertyShape.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = ShaclCorePropertyShape.$Identifier || (ShaclCorePropertyShape.$Identifier = {}));
+    function isShaclCorePropertyShape(object) {
+        switch (object.$type) {
+            case "ShaclCorePropertyShape":
+                return true;
+            default:
+                return false;
+        }
+    }
+    ShaclCorePropertyShape.isShaclCorePropertyShape = isShaclCorePropertyShape;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
+        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
         return ShaclCorePropertyShape.$propertiesFromRdf({
-            ...context,
+            context,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
@@ -1000,209 +1292,142 @@ export var ShaclCorePropertyShape;
         });
     }
     ShaclCorePropertyShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
-    // @ts-ignore
-    ...$context }) {
-        const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
-            ...$context,
+    function $propertiesFromRdf($parameters) {
+        return BaseShaclCoreShapeStatic.$propertiesFromRdf({
+            ...$parameters,
             ignoreRdfType: true,
-            objectSet: $objectSet,
-            preferredLanguages: $preferredLanguages,
-            resource: $resource,
-        });
-        if ($super0Either.isLeft()) {
-            return $super0Either;
-        }
-        const $super0 = $super0Either.unsafeCoerce();
-        if (!$ignoreRdfType) {
-            const $rdfTypeCheck = $resource
-                .value($RdfVocabularies.rdf.type)
+        }).chain(($super0) => (!$parameters.ignoreRdfType
+            ? $parameters.resource
+                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
                 switch (actualRdfType.value) {
                     case "http://www.w3.org/ns/shacl#PropertyShape":
-                        return purify.Either.of(true);
+                        return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(ShaclCorePropertyShape.$fromRdfType)) {
-                    return purify.Either.of(true);
+                if ($parameters.resource.isInstanceOf(ShaclCorePropertyShape.$fromRdfType, { graph: $parameters.graph })) {
+                    return Right(true);
                 }
-                return 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)`));
-            });
-            if ($rdfTypeCheck.isLeft()) {
-                return $rdfTypeCheck;
-            }
-        }
-        const $identifier = $resource.identifier;
-        const $type = "ShaclCorePropertyShape";
-        const _defaultValueEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.defaultValue["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => values.chainMap((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((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: ShaclCorePropertyShape.$properties.defaultValue["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_defaultValueEither.isLeft()) {
-            return _defaultValueEither;
-        }
-        const defaultValue = _defaultValueEither.unsafeCoerce();
-        const _descriptionsEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.descriptions["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: ShaclCorePropertyShape.$properties.descriptions["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCorePropertyShape.$properties.descriptions["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_descriptionsEither.isLeft()) {
-            return _descriptionsEither;
-        }
-        const descriptions = _descriptionsEither.unsafeCoerce();
-        const _groupsEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.groups["identifier"], { unique: true }))
+                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $parameters.resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $parameters.resource.identifier,
+        }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCorePropertyShape.$properties.groups["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_groupsEither.isLeft()) {
-            return _groupsEither;
-        }
-        const groups = _groupsEither.unsafeCoerce();
-        const _namesEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.names["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("ShaclCorePropertyShape").chain(($type) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.defaultValue,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $parameters.resource,
+                            propertyPath: ShaclCorePropertyShape.$schema.properties
+                                .defaultValue.path,
+                        }));
                 }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: ShaclCorePropertyShape.$properties.names["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCorePropertyShape.$properties.names["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_namesEither.isLeft()) {
-            return _namesEither;
-        }
-        const names = _namesEither.unsafeCoerce();
-        const _orderEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.order["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toNumber()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: ShaclCorePropertyShape.$properties.order["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_orderEither.isLeft()) {
-            return _orderEither;
-        }
-        const order = _orderEither.unsafeCoerce();
-        const _pathEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.path["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toResource().chain((resource) => PropertyPath.$fromRdf(resource, {
-            ...$context,
-            ignoreRdfType: true,
-            objectSet: $objectSet,
-            preferredLanguages: $preferredLanguages,
-        }))))
-            .chain((values) => values.head());
-        if (_pathEither.isLeft()) {
-            return _pathEither;
-        }
-        const path = _pathEither.unsafeCoerce();
-        const _uniqueLangEither = purify.Either.of($resource.values(ShaclCorePropertyShape.$properties.uniqueLang["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toBoolean()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: ShaclCorePropertyShape.$properties.uniqueLang["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_uniqueLangEither.isLeft()) {
-            return _uniqueLangEither;
-        }
-        const uniqueLang = _uniqueLangEither.unsafeCoerce();
-        return purify.Either.of({
+            })))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: ShaclCorePropertyShape.$schema.properties
+                        .defaultValue.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((defaultValue) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.descriptions,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCorePropertyShape.$schema.properties
+                    .descriptions.path,
+                value: valuesArray,
+            })),
+        }).chain((descriptions) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.groups,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCorePropertyShape.$schema.properties.groups
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((groups) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.names,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCorePropertyShape.$schema.properties.names
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((names) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.order,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toFloat()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: ShaclCorePropertyShape.$schema.properties
+                        .order.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((order) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.path,
+            typeFromRdf: (resourceValues) => resourceValues.chain((values) => values.chainMap((value) => value.toResource().chain((resource) => PropertyPath.$fromRdf(resource, {
+                context: $parameters.context,
+                ignoreRdfType: true,
+                objectSet: $parameters.objectSet,
+                preferredLanguages: $parameters.preferredLanguages,
+            })))),
+        }).chain((path) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyShape.$schema.properties.uniqueLang,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: ShaclCorePropertyShape.$schema
+                        .properties.uniqueLang.path,
+                    value: Maybe.empty(),
+                })),
+        }).map((uniqueLang) => ({
             ...$super0,
             $identifier,
             $type,
@@ -1213,87 +1438,146 @@ export var ShaclCorePropertyShape;
             order,
             path,
             uniqueLang,
-        });
+        }))))))))))));
     }
     ShaclCorePropertyShape.$propertiesFromRdf = $propertiesFromRdf;
     function $toRdf(_shaclCorePropertyShape, options) {
-        const ignoreRdfType = !!options?.ignoreRdfType;
-        const mutateGraph = options?.mutateGraph;
         const resourceSet = options?.resourceSet ??
-            new rdfjsResource.MutableResourceSet({
-                dataFactory,
-                dataset: datasetFactory.dataset(),
-            });
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCorePropertyShape, {
             ignoreRdfType: true,
-            mutateGraph,
+            graph: options?.graph,
             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.toList());
-        resource.add(ShaclCorePropertyShape.$properties.descriptions["identifier"], ..._shaclCorePropertyShape.descriptions.flatMap((item) => [item]));
-        resource.add(ShaclCorePropertyShape.$properties.groups["identifier"], ..._shaclCorePropertyShape.groups.flatMap((item) => [item]));
-        resource.add(ShaclCorePropertyShape.$properties.names["identifier"], ..._shaclCorePropertyShape.names.flatMap((item) => [item]));
-        resource.add(ShaclCorePropertyShape.$properties.order["identifier"], ..._shaclCorePropertyShape.order.toList());
-        resource.add(ShaclCorePropertyShape.$properties.path["identifier"], ...[
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), options?.graph);
+        }
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), _shaclCorePropertyShape.defaultValue.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), _shaclCorePropertyShape.descriptions.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), _shaclCorePropertyShape.groups.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), _shaclCorePropertyShape.names.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), _shaclCorePropertyShape.order
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.double),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), [
             PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
-                mutateGraph: mutateGraph,
+                graph: options?.graph,
                 resourceSet: resourceSet,
             }).identifier,
-        ]);
-        resource.add(ShaclCorePropertyShape.$properties.uniqueLang["identifier"], ..._shaclCorePropertyShape.uniqueLang.toList().flat());
+        ], options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), _shaclCorePropertyShape.uniqueLang
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), options?.graph);
         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.$schema = {
+        properties: {
+            ...BaseShaclCoreShapeStatic.$schema.properties,
+            defaultValue: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Term" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
+            },
+            descriptions: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+            },
+            groups: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+            },
+            names: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+            },
+            order: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Float" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+            },
+            path: {
+                kind: "Shacl",
+                type: () => PropertyPath.$schema,
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+            },
+            uniqueLang: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+            },
         },
     };
 })(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
 export var ShaclCorePropertyGroup;
 (function (ShaclCorePropertyGroup) {
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.comments !== undefined &&
+            !$filterArray($filterString)(filter.comments, value.comments)) {
+            return false;
+        }
+        if (filter.labels !== undefined &&
+            !$filterArray($filterString)(filter.labels, value.labels)) {
+            return false;
+        }
+        return true;
+    }
+    ShaclCorePropertyGroup.$filter = $filter;
     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,
-            }));
-        }
-        $Identifier.fromString = fromString;
-        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
     })($Identifier = ShaclCorePropertyGroup.$Identifier || (ShaclCorePropertyGroup.$Identifier = {}));
+    function isShaclCorePropertyGroup(object) {
+        switch (object.$type) {
+            case "ShaclCorePropertyGroup":
+                return true;
+            default:
+                return false;
+        }
+    }
+    ShaclCorePropertyGroup.isShaclCorePropertyGroup = isShaclCorePropertyGroup;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
+        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
         return ShaclCorePropertyGroup.$propertiesFromRdf({
-            ...context,
+            context,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
@@ -1301,153 +1585,151 @@ export var ShaclCorePropertyGroup;
         });
     }
     ShaclCorePropertyGroup.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
-    // @ts-ignore
-    ...$context }) {
-        if (!$ignoreRdfType) {
-            const $rdfTypeCheck = $resource
-                .value($RdfVocabularies.rdf.type)
+    function $propertiesFromRdf($parameters) {
+        return (!$parameters.ignoreRdfType
+            ? $parameters.resource
+                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
                 switch (actualRdfType.value) {
                     case "http://www.w3.org/ns/shacl#PropertyGroup":
-                        return purify.Either.of(true);
+                        return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(ShaclCorePropertyGroup.$fromRdfType)) {
-                    return purify.Either.of(true);
+                if ($parameters.resource.isInstanceOf(ShaclCorePropertyGroup.$fromRdfType, { graph: $parameters.graph })) {
+                    return Right(true);
                 }
-                return 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)`));
-            });
-            if ($rdfTypeCheck.isLeft()) {
-                return $rdfTypeCheck;
-            }
-        }
-        const $identifier = $resource.identifier;
-        const $type = "ShaclCorePropertyGroup";
-        const _commentsEither = purify.Either.of($resource.values(ShaclCorePropertyGroup.$properties.comments["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: ShaclCorePropertyGroup.$properties.comments["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCorePropertyGroup.$properties.comments["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_commentsEither.isLeft()) {
-            return _commentsEither;
-        }
-        const comments = _commentsEither.unsafeCoerce();
-        const _labelsEither = purify.Either.of($resource.values(ShaclCorePropertyGroup.$properties.labels["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
-                }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: ShaclCorePropertyGroup.$properties.labels["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCorePropertyGroup.$properties.labels["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_labelsEither.isLeft()) {
-            return _labelsEither;
-        }
-        const labels = _labelsEither.unsafeCoerce();
-        return purify.Either.of({ $identifier, $type, comments, labels });
+                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $parameters.resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $parameters.resource.identifier,
+        }).toValues())
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("ShaclCorePropertyGroup").chain(($type) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyGroup.$schema.properties.comments,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCorePropertyGroup.$schema.properties.comments.path,
+                value: valuesArray,
+            })),
+        }).chain((comments) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCorePropertyGroup.$schema.properties.labels,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCorePropertyGroup.$schema.properties.labels.path,
+                value: valuesArray,
+            })),
+        }).map((labels) => ({ $identifier, $type, comments, labels }))))));
     }
     ShaclCorePropertyGroup.$propertiesFromRdf = $propertiesFromRdf;
     function $toRdf(_shaclCorePropertyGroup, options) {
-        const ignoreRdfType = !!options?.ignoreRdfType;
-        const mutateGraph = options?.mutateGraph;
         const resourceSet = options?.resourceSet ??
-            new rdfjsResource.MutableResourceSet({
-                dataFactory,
-                dataset: datasetFactory.dataset(),
-            });
-        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.flatMap((item) => [item]));
-        resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], ..._shaclCorePropertyGroup.labels.flatMap((item) => [item]));
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_shaclCorePropertyGroup.$identifier);
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
+        }
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _shaclCorePropertyGroup.comments.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _shaclCorePropertyGroup.labels.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
         return resource;
     }
     ShaclCorePropertyGroup.$toRdf = $toRdf;
-    ShaclCorePropertyGroup.$properties = {
-        comments: {
-            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
-        },
-        labels: {
-            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+    ShaclCorePropertyGroup.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "TypeDiscriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["ShaclCorePropertyGroup"],
+                }),
+            },
+            comments: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
         },
     };
 })(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
 export var ShaclCoreNodeShape;
 (function (ShaclCoreNodeShape) {
+    function $filter(filter, value) {
+        if (!BaseShaclCoreShapeStatic.$filter(filter, value)) {
+            return false;
+        }
+        if (filter.closed !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.closed, value.closed)) {
+            return false;
+        }
+        if (filter.ignoredProperties !== undefined &&
+            !$filterMaybe($filterArray($filterIri))(filter.ignoredProperties, value.ignoredProperties)) {
+            return false;
+        }
+        if (filter.properties !== undefined &&
+            !$filterArray($filterIdentifier)(filter.properties, value.properties)) {
+            return false;
+        }
+        return true;
+    }
+    ShaclCoreNodeShape.$filter = $filter;
     ShaclCoreNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
-    ShaclCoreNodeShape.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = ShaclCoreNodeShape.$Identifier || (ShaclCoreNodeShape.$Identifier = {}));
+    function isShaclCoreNodeShape(object) {
+        switch (object.$type) {
+            case "ShaclCoreNodeShape":
+                return true;
+            default:
+                return false;
+        }
+    }
+    ShaclCoreNodeShape.isShaclCoreNodeShape = isShaclCoreNodeShape;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
+        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
         return ShaclCoreNodeShape.$propertiesFromRdf({
-            ...context,
+            context,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
@@ -1455,179 +1737,203 @@ export var ShaclCoreNodeShape;
         });
     }
     ShaclCoreNodeShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
-    // @ts-ignore
-    ...$context }) {
-        const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
-            ...$context,
+    function $propertiesFromRdf($parameters) {
+        return BaseShaclCoreShapeStatic.$propertiesFromRdf({
+            ...$parameters,
             ignoreRdfType: true,
-            objectSet: $objectSet,
-            preferredLanguages: $preferredLanguages,
-            resource: $resource,
-        });
-        if ($super0Either.isLeft()) {
-            return $super0Either;
-        }
-        const $super0 = $super0Either.unsafeCoerce();
-        if (!$ignoreRdfType) {
-            const $rdfTypeCheck = $resource
-                .value($RdfVocabularies.rdf.type)
+        }).chain(($super0) => (!$parameters.ignoreRdfType
+            ? $parameters.resource
+                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
                 switch (actualRdfType.value) {
                     case "http://www.w3.org/ns/shacl#NodeShape":
-                        return purify.Either.of(true);
+                        return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(ShaclCoreNodeShape.$fromRdfType)) {
-                    return purify.Either.of(true);
+                if ($parameters.resource.isInstanceOf(ShaclCoreNodeShape.$fromRdfType, { graph: $parameters.graph })) {
+                    return Right(true);
                 }
-                return 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)`));
-            });
-            if ($rdfTypeCheck.isLeft()) {
-                return $rdfTypeCheck;
-            }
-        }
-        const $identifier = $resource.identifier;
-        const $type = "ShaclCoreNodeShape";
-        const _closedEither = purify.Either.of($resource.values(ShaclCoreNodeShape.$properties.closed["identifier"], { unique: true }))
-            .chain((values) => values.chainMap((value) => value.toBoolean()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: ShaclCoreNodeShape.$properties.closed["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_closedEither.isLeft()) {
-            return _closedEither;
-        }
-        const closed = _closedEither.unsafeCoerce();
-        const _ignoredPropertiesEither = purify.Either.of($resource.values(ShaclCoreNodeShape.$properties.ignoredProperties["identifier"], {
-            unique: true,
-        }))
-            .chain((values) => values.chainMap((value) => value.toList()))
-            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
-            objects: valueList,
-            predicate: ShaclCoreNodeShape.$properties.ignoredProperties["identifier"],
-            subject: $resource,
-        })).chain((values) => values.chainMap((value) => value.toIri()))))
-            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-            .map((values) => values.length > 0
-            ? values.map((value) => purify.Maybe.of(value))
-            : rdfjsResource.Resource.Values.fromValue({
-                object: purify.Maybe.empty(),
-                predicate: ShaclCoreNodeShape.$properties.ignoredProperties["identifier"],
-                subject: $resource,
-            }))
-            .chain((values) => values.head());
-        if (_ignoredPropertiesEither.isLeft()) {
-            return _ignoredPropertiesEither;
-        }
-        const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
-        const _propertiesEither = purify.Either.of($resource.values(ShaclCoreNodeShape.$properties.properties["identifier"], { unique: true }))
+                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $parameters.resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $parameters.resource.identifier,
+        }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: ShaclCoreNodeShape.$properties.properties["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_propertiesEither.isLeft()) {
-            return _propertiesEither;
-        }
-        const properties = _propertiesEither.unsafeCoerce();
-        return purify.Either.of({
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("ShaclCoreNodeShape").chain(($type) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCoreNodeShape.$schema.properties.closed,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: ShaclCoreNodeShape.$schema.properties.closed
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((closed) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCoreNodeShape.$schema.properties.ignoredProperties,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCoreNodeShape.$schema.properties
+                    .ignoredProperties.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIri()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $parameters.resource,
+                    propertyPath: ShaclCoreNodeShape.$schema.properties
+                        .ignoredProperties.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((ignoredProperties) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: ShaclCoreNodeShape.$schema.properties.properties,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: ShaclCoreNodeShape.$schema.properties.properties
+                    .path,
+                value: valuesArray,
+            })),
+        }).map((properties) => ({
             ...$super0,
             $identifier,
             $type,
             closed,
             ignoredProperties,
             properties,
-        });
+        }))))))));
     }
     ShaclCoreNodeShape.$propertiesFromRdf = $propertiesFromRdf;
     function $toRdf(_shaclCoreNodeShape, options) {
-        const ignoreRdfType = !!options?.ignoreRdfType;
-        const mutateGraph = options?.mutateGraph;
         const resourceSet = options?.resourceSet ??
-            new rdfjsResource.MutableResourceSet({
-                dataFactory,
-                dataset: datasetFactory.dataset(),
-            });
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCoreNodeShape, {
             ignoreRdfType: true,
-            mutateGraph,
+            graph: options?.graph,
             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.toList().flat());
-        resource.add(ShaclCoreNodeShape.$properties.ignoredProperties["identifier"], ..._shaclCoreNodeShape.ignoredProperties.toList().flatMap((value) => [
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), options?.graph);
+        }
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), _shaclCoreNodeShape.closed
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), _shaclCoreNodeShape.ignoredProperties.toList().flatMap((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);
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
                         currentSubListResource = newSubListResource;
                     }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
                     if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
                     }
                     return { currentSubListResource, listResource };
                 }, {
                     currentSubListResource: null,
-                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
-        ]));
-        resource.add(ShaclCoreNodeShape.$properties.properties["identifier"], ..._shaclCoreNodeShape.properties.flatMap((item) => [item]));
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), _shaclCoreNodeShape.properties.flatMap((item) => [item]), options?.graph);
         return resource;
     }
     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"),
-        },
+    ShaclCoreNodeShape.$schema = {
         properties: {
-            identifier: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+            ...BaseShaclCoreShapeStatic.$schema.properties,
+            closed: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+            },
+            ignoredProperties: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Iri" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+            },
+            properties: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+            },
         },
     };
 })(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
 export var OwlOntology;
 (function (OwlOntology) {
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.labels !== undefined &&
+            !$filterArray($filterString)(filter.labels, value.labels)) {
+            return false;
+        }
+        return true;
+    }
+    OwlOntology.$filter = $filter;
     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,
-            }));
-        }
-        $Identifier.fromString = fromString;
-        $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
     })($Identifier = OwlOntology.$Identifier || (OwlOntology.$Identifier = {}));
+    function isOwlOntology(object) {
+        switch (object.$type) {
+            case "OwlOntology":
+                return true;
+            default:
+                return false;
+        }
+    }
+    OwlOntology.isOwlOntology = isOwlOntology;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
+        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
         return OwlOntology.$propertiesFromRdf({
-            ...context,
+            context,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
@@ -1635,102 +1941,343 @@ export var OwlOntology;
         });
     }
     OwlOntology.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
-    // @ts-ignore
-    ...$context }) {
-        if (!$ignoreRdfType) {
-            const $rdfTypeCheck = $resource
-                .value($RdfVocabularies.rdf.type)
+    function $propertiesFromRdf($parameters) {
+        return (!$parameters.ignoreRdfType
+            ? $parameters.resource
+                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
                 switch (actualRdfType.value) {
                     case "http://www.w3.org/2002/07/owl#Ontology":
-                        return purify.Either.of(true);
+                        return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(OwlOntology.$fromRdfType)) {
-                    return purify.Either.of(true);
-                }
-                return 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)`));
-            });
-            if ($rdfTypeCheck.isLeft()) {
-                return $rdfTypeCheck;
-            }
-        }
-        const $identifier = $resource.identifier;
-        const $type = "OwlOntology";
-        const _labelsEither = purify.Either.of($resource.values(OwlOntology.$properties.labels["identifier"], { unique: true }))
-            .chain((values) => {
-            if (!$preferredLanguages || $preferredLanguages.length === 0) {
-                return purify.Either.of(values);
-            }
-            const literalValuesEither = values.chainMap((value) => value.toLiteral());
-            if (literalValuesEither.isLeft()) {
-                return literalValuesEither;
-            }
-            const literalValues = literalValuesEither.unsafeCoerce();
-            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-            // Within a preferredLanguage the literals may be in any order.
-            let filteredLiteralValues;
-            for (const preferredLanguage of $preferredLanguages) {
-                if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
-                }
-                else {
-                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === preferredLanguage)
-                        .toArray());
+                if ($parameters.resource.isInstanceOf(OwlOntology.$fromRdfType, {
+                    graph: $parameters.graph,
+                })) {
+                    return Right(true);
                 }
-            }
-            return purify.Either.of(filteredLiteralValues.map((literalValue) => new rdfjsResource.Resource.Value({
-                object: literalValue,
-                predicate: OwlOntology.$properties.labels["identifier"],
-                subject: $resource,
-            })));
-        })
-            .chain((values) => values.chainMap((value) => value.toLiteral()))
-            .map((values) => values.toArray())
-            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
-            object: valuesArray,
-            predicate: OwlOntology.$properties.labels["identifier"],
-            subject: $resource,
-        }))
-            .chain((values) => values.head());
-        if (_labelsEither.isLeft()) {
-            return _labelsEither;
-        }
-        const labels = _labelsEither.unsafeCoerce();
-        return purify.Either.of({ $identifier, $type, labels });
+                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $parameters.resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $parameters.resource.identifier,
+        }).toValues())
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("OwlOntology").chain(($type) => $shaclPropertyFromRdf({
+            graph: $parameters.graph,
+            resource: $parameters.resource,
+            propertySchema: OwlOntology.$schema.properties.labels,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $parameters.resource,
+                propertyPath: OwlOntology.$schema.properties.labels.path,
+                value: valuesArray,
+            })),
+        }).map((labels) => ({ $identifier, $type, labels })))));
     }
     OwlOntology.$propertiesFromRdf = $propertiesFromRdf;
     function $toRdf(_owlOntology, options) {
-        const ignoreRdfType = !!options?.ignoreRdfType;
-        const mutateGraph = options?.mutateGraph;
         const resourceSet = options?.resourceSet ??
-            new rdfjsResource.MutableResourceSet({
-                dataFactory,
-                dataset: datasetFactory.dataset(),
-            });
-        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"));
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_owlOntology.$identifier);
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
         }
-        resource.add(OwlOntology.$properties.labels["identifier"], ..._owlOntology.labels.flatMap((item) => [item]));
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _owlOntology.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         return resource;
     }
     OwlOntology.$toRdf = $toRdf;
-    OwlOntology.$properties = {
-        labels: {
-            identifier: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+    OwlOntology.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "TypeDiscriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["OwlOntology"],
+                }),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
         },
     };
 })(OwlOntology || (OwlOntology = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (ShaclCoreNodeShape.isShaclCoreNodeShape(value) &&
+            filter.on?.ShaclCoreNodeShape &&
+            !ShaclCoreNodeShape.$filter(filter.on.ShaclCoreNodeShape, value)) {
+            return false;
+        }
+        if (ShaclCorePropertyShape.isShaclCorePropertyShape(value) &&
+            filter.on?.ShaclCorePropertyShape &&
+            !ShaclCorePropertyShape.$filter(filter.on.ShaclCorePropertyShape, value)) {
+            return false;
+        }
+        return true;
+    }
+    ShaclCoreShape.$filter = $filter;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = ShaclCoreShape.$Identifier || (ShaclCoreShape.$Identifier = {}));
+    function isShaclCoreShape(object) {
+        return (ShaclCoreNodeShape.isShaclCoreNodeShape(object) ||
+            ShaclCorePropertyShape.isShaclCorePropertyShape(object));
+    }
+    ShaclCoreShape.isShaclCoreShape = isShaclCoreShape;
+    ShaclCoreShape.$schema = {
+        properties: {
+            and: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+            },
+            classes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+            },
+            comments: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            datatype: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+            },
+            deactivated: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+            },
+            flags: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+            },
+            hasValues: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Term" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+            },
+            in_: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Term" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+            languageIn: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "String" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+            },
+            maxCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+            },
+            maxLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+            },
+            minCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+            },
+            minExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+            },
+            minInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+            },
+            minLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+            },
+            nodeKind: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+            },
+            nodes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
+            not: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+            },
+            or: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+            },
+            patterns: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+            },
+            xone: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+            },
+        },
+    };
     function $fromRdf(resource, options) {
         return ShaclCoreNodeShape.$fromRdf(resource, {
             ...options,
@@ -1741,128 +2288,145 @@ export var ShaclCoreShape;
         }));
     }
     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");
+        if (ShaclCoreNodeShape.isShaclCoreNodeShape(_shaclCoreShape)) {
+            return ShaclCoreNodeShape.$toRdf(_shaclCoreShape, _parameters);
         }
+        if (ShaclCorePropertyShape.isShaclCorePropertyShape(_shaclCoreShape)) {
+            return ShaclCorePropertyShape.$toRdf(_shaclCoreShape, _parameters);
+        }
+        throw new Error("unrecognized type");
     }
     ShaclCoreShape.$toRdf = $toRdf;
 })(ShaclCoreShape || (ShaclCoreShape = {}));
-export class $ForwardingObjectSet {
-    owlOntology(identifier) {
-        return this.$delegate.owlOntology(identifier);
-    }
-    owlOntologyIdentifiers(query) {
-        return this.$delegate.owlOntologyIdentifiers(query);
-    }
-    owlOntologies(query) {
-        return this.$delegate.owlOntologies(query);
-    }
-    owlOntologiesCount(query) {
-        return this.$delegate.owlOntologiesCount(query);
-    }
-    shaclCoreNodeShape(identifier) {
-        return this.$delegate.shaclCoreNodeShape(identifier);
-    }
-    shaclCoreNodeShapeIdentifiers(query) {
-        return this.$delegate.shaclCoreNodeShapeIdentifiers(query);
-    }
-    shaclCoreNodeShapes(query) {
-        return this.$delegate.shaclCoreNodeShapes(query);
-    }
-    shaclCoreNodeShapesCount(query) {
-        return this.$delegate.shaclCoreNodeShapesCount(query);
-    }
-    shaclCorePropertyGroup(identifier) {
-        return this.$delegate.shaclCorePropertyGroup(identifier);
-    }
-    shaclCorePropertyGroupIdentifiers(query) {
-        return this.$delegate.shaclCorePropertyGroupIdentifiers(query);
-    }
-    shaclCorePropertyGroups(query) {
-        return this.$delegate.shaclCorePropertyGroups(query);
-    }
-    shaclCorePropertyGroupsCount(query) {
-        return this.$delegate.shaclCorePropertyGroupsCount(query);
-    }
-    shaclCorePropertyShape(identifier) {
-        return this.$delegate.shaclCorePropertyShape(identifier);
-    }
-    shaclCorePropertyShapeIdentifiers(query) {
-        return this.$delegate.shaclCorePropertyShapeIdentifiers(query);
-    }
-    shaclCorePropertyShapes(query) {
-        return this.$delegate.shaclCorePropertyShapes(query);
-    }
-    shaclCorePropertyShapesCount(query) {
-        return this.$delegate.shaclCorePropertyShapesCount(query);
-    }
-    shaclCoreShape(identifier) {
-        return this.$delegate.shaclCoreShape(identifier);
+export var $Object;
+(function ($Object) {
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (OwlOntology.isOwlOntology(value) &&
+            filter.on?.OwlOntology &&
+            !OwlOntology.$filter(filter.on.OwlOntology, value)) {
+            return false;
+        }
+        if (ShaclCoreNodeShape.isShaclCoreNodeShape(value) &&
+            filter.on?.ShaclCoreNodeShape &&
+            !ShaclCoreNodeShape.$filter(filter.on.ShaclCoreNodeShape, value)) {
+            return false;
+        }
+        if (ShaclCorePropertyGroup.isShaclCorePropertyGroup(value) &&
+            filter.on?.ShaclCorePropertyGroup &&
+            !ShaclCorePropertyGroup.$filter(filter.on.ShaclCorePropertyGroup, value)) {
+            return false;
+        }
+        if (ShaclCorePropertyShape.isShaclCorePropertyShape(value) &&
+            filter.on?.ShaclCorePropertyShape &&
+            !ShaclCorePropertyShape.$filter(filter.on.ShaclCorePropertyShape, value)) {
+            return false;
+        }
+        if (BaseShaclCoreShapeStatic.isBaseShaclCoreShape(value) &&
+            filter.on?.BaseShaclCoreShape &&
+            !BaseShaclCoreShapeStatic.$filter(filter.on.BaseShaclCoreShape, value)) {
+            return false;
+        }
+        return true;
+    }
+    $Object.$filter = $filter;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = $Object.$Identifier || ($Object.$Identifier = {}));
+    $Object.$schema = {
+        properties: {
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+        },
+    };
+    function $fromRdf(resource, options) {
+        return OwlOntology.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        })
+            .altLazy(() => ShaclCoreNodeShape.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        }))
+            .altLazy(() => ShaclCorePropertyGroup.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        }))
+            .altLazy(() => ShaclCorePropertyShape.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        }));
     }
-    shaclCoreShapeIdentifiers(query) {
-        return this.$delegate.shaclCoreShapeIdentifiers(query);
+    $Object.$fromRdf = $fromRdf;
+    function $toRdf(_object, _parameters) {
+        if (OwlOntology.isOwlOntology(_object)) {
+            return OwlOntology.$toRdf(_object, _parameters);
+        }
+        if (ShaclCoreNodeShape.isShaclCoreNodeShape(_object)) {
+            return ShaclCoreNodeShape.$toRdf(_object, _parameters);
+        }
+        if (ShaclCorePropertyGroup.isShaclCorePropertyGroup(_object)) {
+            return ShaclCorePropertyGroup.$toRdf(_object, _parameters);
+        }
+        if (ShaclCorePropertyShape.isShaclCorePropertyShape(_object)) {
+            return ShaclCorePropertyShape.$toRdf(_object, _parameters);
+        }
+        throw new Error("unrecognized type");
     }
-    shaclCoreShapes(query) {
-        return this.$delegate.shaclCoreShapes(query);
+    $Object.$toRdf = $toRdf;
+})($Object || ($Object = {}));
+export class $RdfjsDatasetObjectSet {
+    $graph;
+    #dataset;
+    constructor(dataset, options) {
+        this.#dataset = dataset;
+        this.$graph = options?.graph;
     }
-    shaclCoreShapesCount(query) {
-        return this.$delegate.shaclCoreShapesCount(query);
+    $dataset() {
+        if (typeof this.#dataset === "object") {
+            return this.#dataset;
+        }
+        return this.#dataset();
     }
-}
-export class $RdfjsDatasetObjectSet {
-    resourceSet;
-    constructor({ dataset }) {
-        this.resourceSet = new rdfjsResource.ResourceSet({ dataset });
+    $resourceSet() {
+        return new ResourceSet(this.$dataset(), { dataFactory: dataFactory });
     }
     async owlOntology(identifier) {
         return this.owlOntologySync(identifier);
     }
     owlOntologySync(identifier) {
-        return this.owlOntologiesSync({
-            where: { identifiers: [identifier], type: "identifiers" },
-        }).map((objects) => objects[0]);
+        return this.owlOntologiesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async owlOntologyCount(query) {
+        return this.owlOntologyCountSync(query);
+    }
+    owlOntologyCountSync(query) {
+        return this.owlOntologiesSync(query).map((objects) => objects.length);
     }
     async owlOntologyIdentifiers(query) {
         return this.owlOntologyIdentifiersSync(query);
     }
     owlOntologyIdentifiersSync(query) {
-        return this.$objectIdentifiersSync({
-            $fromRdf: OwlOntology.$fromRdf,
-            $fromRdfTypes: [OwlOntology.$fromRdfType],
-        }, query);
+        return this.owlOntologiesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
     async owlOntologies(query) {
         return this.owlOntologiesSync(query);
     }
     owlOntologiesSync(query) {
         return this.$objectsSync({
-            $fromRdf: OwlOntology.$fromRdf,
-            $fromRdfTypes: [OwlOntology.$fromRdfType],
-        }, query);
-    }
-    async owlOntologiesCount(query) {
-        return this.owlOntologiesCountSync(query);
-    }
-    owlOntologiesCountSync(query) {
-        return this.$objectsCountSync({
+            $filter: OwlOntology.$filter,
             $fromRdf: OwlOntology.$fromRdf,
             $fromRdfTypes: [OwlOntology.$fromRdfType],
         }, query);
@@ -1871,33 +2435,26 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreNodeShapeSync(identifier);
     }
     shaclCoreNodeShapeSync(identifier) {
-        return this.shaclCoreNodeShapesSync({
-            where: { identifiers: [identifier], type: "identifiers" },
-        }).map((objects) => objects[0]);
+        return this.shaclCoreNodeShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async shaclCoreNodeShapeCount(query) {
+        return this.shaclCoreNodeShapeCountSync(query);
+    }
+    shaclCoreNodeShapeCountSync(query) {
+        return this.shaclCoreNodeShapesSync(query).map((objects) => objects.length);
     }
     async shaclCoreNodeShapeIdentifiers(query) {
         return this.shaclCoreNodeShapeIdentifiersSync(query);
     }
     shaclCoreNodeShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync({
-            $fromRdf: ShaclCoreNodeShape.$fromRdf,
-            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
-        }, query);
+        return this.shaclCoreNodeShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
     async shaclCoreNodeShapes(query) {
         return this.shaclCoreNodeShapesSync(query);
     }
     shaclCoreNodeShapesSync(query) {
         return this.$objectsSync({
-            $fromRdf: ShaclCoreNodeShape.$fromRdf,
-            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
-        }, query);
-    }
-    async shaclCoreNodeShapesCount(query) {
-        return this.shaclCoreNodeShapesCountSync(query);
-    }
-    shaclCoreNodeShapesCountSync(query) {
-        return this.$objectsCountSync({
+            $filter: ShaclCoreNodeShape.$filter,
             $fromRdf: ShaclCoreNodeShape.$fromRdf,
             $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
         }, query);
@@ -1906,33 +2463,26 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCorePropertyGroupSync(identifier);
     }
     shaclCorePropertyGroupSync(identifier) {
-        return this.shaclCorePropertyGroupsSync({
-            where: { identifiers: [identifier], type: "identifiers" },
-        }).map((objects) => objects[0]);
+        return this.shaclCorePropertyGroupsSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async shaclCorePropertyGroupCount(query) {
+        return this.shaclCorePropertyGroupCountSync(query);
+    }
+    shaclCorePropertyGroupCountSync(query) {
+        return this.shaclCorePropertyGroupsSync(query).map((objects) => objects.length);
     }
     async shaclCorePropertyGroupIdentifiers(query) {
         return this.shaclCorePropertyGroupIdentifiersSync(query);
     }
     shaclCorePropertyGroupIdentifiersSync(query) {
-        return this.$objectIdentifiersSync({
-            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
-        }, query);
+        return this.shaclCorePropertyGroupsSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
     async shaclCorePropertyGroups(query) {
         return this.shaclCorePropertyGroupsSync(query);
     }
     shaclCorePropertyGroupsSync(query) {
         return this.$objectsSync({
-            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
-        }, query);
-    }
-    async shaclCorePropertyGroupsCount(query) {
-        return this.shaclCorePropertyGroupsCountSync(query);
-    }
-    shaclCorePropertyGroupsCountSync(query) {
-        return this.$objectsCountSync({
+            $filter: ShaclCorePropertyGroup.$filter,
             $fromRdf: ShaclCorePropertyGroup.$fromRdf,
             $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
         }, query);
@@ -1941,33 +2491,26 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCorePropertyShapeSync(identifier);
     }
     shaclCorePropertyShapeSync(identifier) {
-        return this.shaclCorePropertyShapesSync({
-            where: { identifiers: [identifier], type: "identifiers" },
-        }).map((objects) => objects[0]);
+        return this.shaclCorePropertyShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async shaclCorePropertyShapeCount(query) {
+        return this.shaclCorePropertyShapeCountSync(query);
+    }
+    shaclCorePropertyShapeCountSync(query) {
+        return this.shaclCorePropertyShapesSync(query).map((objects) => objects.length);
     }
     async shaclCorePropertyShapeIdentifiers(query) {
         return this.shaclCorePropertyShapeIdentifiersSync(query);
     }
     shaclCorePropertyShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync({
-            $fromRdf: ShaclCorePropertyShape.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
-        }, query);
+        return this.shaclCorePropertyShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
     async shaclCorePropertyShapes(query) {
         return this.shaclCorePropertyShapesSync(query);
     }
     shaclCorePropertyShapesSync(query) {
         return this.$objectsSync({
-            $fromRdf: ShaclCorePropertyShape.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
-        }, query);
-    }
-    async shaclCorePropertyShapesCount(query) {
-        return this.shaclCorePropertyShapesCountSync(query);
-    }
-    shaclCorePropertyShapesCountSync(query) {
-        return this.$objectsCountSync({
+            $filter: ShaclCorePropertyShape.$filter,
             $fromRdf: ShaclCorePropertyShape.$fromRdf,
             $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
         }, query);
@@ -1976,24 +2519,19 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreShapeSync(identifier);
     }
     shaclCoreShapeSync(identifier) {
-        return this.shaclCoreShapesSync({
-            where: { identifiers: [identifier], type: "identifiers" },
-        }).map((objects) => objects[0]);
+        return this.shaclCoreShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async shaclCoreShapeCount(query) {
+        return this.shaclCoreShapeCountSync(query);
+    }
+    shaclCoreShapeCountSync(query) {
+        return this.shaclCoreShapesSync(query).map((objects) => objects.length);
     }
     async shaclCoreShapeIdentifiers(query) {
         return this.shaclCoreShapeIdentifiersSync(query);
     }
     shaclCoreShapeIdentifiersSync(query) {
-        return this.$objectUnionIdentifiersSync([
-            {
-                $fromRdf: ShaclCoreNodeShape.$fromRdf,
-                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
-            },
-            {
-                $fromRdf: ShaclCorePropertyShape.$fromRdf,
-                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
-            },
-        ], query);
+        return this.shaclCoreShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
     async shaclCoreShapes(query) {
         return this.shaclCoreShapesSync(query);
@@ -2001,204 +2539,269 @@ export class $RdfjsDatasetObjectSet {
     shaclCoreShapesSync(query) {
         return this.$objectUnionsSync([
             {
+                $filter: ShaclCoreShape.$filter,
                 $fromRdf: ShaclCoreNodeShape.$fromRdf,
                 $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
             },
             {
+                $filter: ShaclCoreShape.$filter,
                 $fromRdf: ShaclCorePropertyShape.$fromRdf,
                 $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
             },
         ], query);
     }
-    async shaclCoreShapesCount(query) {
-        return this.shaclCoreShapesCountSync(query);
+    async object(identifier) {
+        return this.objectSync(identifier);
+    }
+    objectSync(identifier) {
+        return this.objectsSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    }
+    async objectCount(query) {
+        return this.objectCountSync(query);
+    }
+    objectCountSync(query) {
+        return this.objectsSync(query).map((objects) => objects.length);
     }
-    shaclCoreShapesCountSync(query) {
-        return this.$objectUnionsCountSync([
+    async objectIdentifiers(query) {
+        return this.objectIdentifiersSync(query);
+    }
+    objectIdentifiersSync(query) {
+        return this.objectsSync(query).map((objects) => objects.map((object) => object.$identifier));
+    }
+    async objects(query) {
+        return this.objectsSync(query);
+    }
+    objectsSync(query) {
+        return this.$objectUnionsSync([
             {
+                $filter: $Object.$filter,
+                $fromRdf: OwlOntology.$fromRdf,
+                $fromRdfTypes: [OwlOntology.$fromRdfType],
+            },
+            {
+                $filter: $Object.$filter,
                 $fromRdf: ShaclCoreNodeShape.$fromRdf,
                 $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
             },
             {
+                $filter: $Object.$filter,
+                $fromRdf: ShaclCorePropertyGroup.$fromRdf,
+                $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+            },
+            {
+                $filter: $Object.$filter,
                 $fromRdf: ShaclCorePropertyShape.$fromRdf,
                 $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
             },
         ], query);
     }
-    $objectIdentifiersSync(objectType, query) {
-        return this.$objectsSync(objectType, query).map((objects) => objects.map((object) => object.$identifier));
-    }
     $objectsSync(objectType, query) {
+        const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {
-            return purify.Either.of([]);
+            return Right([]);
         }
         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`));
-                        }
+        let resources;
+        const resourceSet = this.$resourceSet(); // Access once, in case it's instantiated lazily
+        let sortResources;
+        if (query?.identifiers) {
+            resources = query.identifiers.map((identifier) => ({
+                resource: resourceSet.resource(identifier),
+            }));
+            sortResources = false;
+        }
+        else if (objectType.$fromRdfTypes.length > 0) {
+            const identifierSet = new $IdentifierSet();
+            resources = [];
+            sortResources = true;
+            for (const fromRdfType of objectType.$fromRdfTypes) {
+                for (const resource of resourceSet.instancesOf(fromRdfType, {
+                    graph,
+                })) {
+                    if (!identifierSet.has(resource.identifier)) {
+                        identifierSet.add(resource.identifier);
+                        resources.push({ resource });
                     }
-                    break;
                 }
             }
-            const objects = [];
-            for (const identifier of identifiers) {
-                const either = objectType.$fromRdf(this.resourceSet.resource(identifier), { objectSet: this });
-                if (either.isLeft()) {
-                    return either;
+        }
+        else {
+            const identifierSet = new $IdentifierSet();
+            resources = [];
+            sortResources = true;
+            for (const quad of resourceSet.dataset) {
+                if (graph && !quad.graph.equals(graph)) {
+                    continue;
                 }
-                objects.push(either.unsafeCoerce());
+                switch (quad.subject.termType) {
+                    case "BlankNode":
+                    case "NamedNode":
+                        break;
+                    default:
+                        continue;
+                }
+                if (identifierSet.has(quad.subject)) {
+                    continue;
+                }
+                identifierSet.add(quad.subject);
+                const resource = resourceSet.resource(quad.subject);
+                // Eagerly eliminate the majority of resources that won't match the object type
+                objectType
+                    .$fromRdf(resource, { graph, objectSet: this })
+                    .ifRight((object) => {
+                    resources.push({ object, resource });
+                });
             }
-            return purify.Either.of(objects);
         }
-        if (objectType.$fromRdfTypes.length === 0) {
-            return purify.Either.of([]);
+        if (sortResources) {
+            // Sort resources by identifier so limit and offset are deterministic
+            resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
         }
-        const resources = [];
-        for (const fromRdfType of objectType.$fromRdfTypes) {
-            for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
-                if (!resources.some((existingResource) => existingResource.identifier.equals(resource.identifier))) {
-                    resources.push(resource);
+        let objectI = 0;
+        const objects = [];
+        for (let { object, resource } of resources) {
+            if (!object) {
+                const objectEither = objectType.$fromRdf(resource, {
+                    graph,
+                    objectSet: this,
+                });
+                if (objectEither.isLeft()) {
+                    return objectEither;
                 }
+                object = objectEither.unsafeCoerce();
             }
-        }
-        // 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, { objectSet: this });
-            if (either.isLeft()) {
-                return either;
+            if (query?.filter && !objectType.$filter(query.filter, object)) {
+                continue;
             }
             if (objectI++ >= offset) {
-                objects.push(either.unsafeCoerce());
+                objects.push(object);
                 if (objects.length === limit) {
-                    return purify.Either.of(objects);
+                    return Right(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));
+        return Right(objects);
     }
     $objectUnionsSync(objectTypes, query) {
+        const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {
-            return purify.Either.of([]);
+            return Right([]);
         }
         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`));
+        let resources;
+        const resourceSet = this.$resourceSet(); // Access once, in case it's instantiated lazily
+        let sortResources;
+        if (query?.identifiers) {
+            resources = query.identifiers.map((identifier) => ({
+                resource: resourceSet.resource(identifier),
+            }));
+            sortResources = false;
+        }
+        else if (objectTypes.every((objectType) => objectType.$fromRdfTypes.length > 0)) {
+            const identifierSet = new $IdentifierSet();
+            resources = [];
+            sortResources = true;
+            for (const objectType of objectTypes) {
+                for (const fromRdfType of objectType.$fromRdfTypes) {
+                    for (const resource of resourceSet.instancesOf(fromRdfType, {
+                        graph,
+                    })) {
+                        if (!identifierSet.has(resource.identifier)) {
+                            identifierSet.add(resource.identifier);
+                            resources.push({ objectType, resource });
                         }
                     }
-                    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, { objectSet: this });
-                    if (either.isRight()) {
-                        objects.push(either.unsafeCoerce());
+        }
+        else {
+            const identifierSet = new $IdentifierSet();
+            resources = [];
+            sortResources = true;
+            for (const quad of resourceSet.dataset) {
+                if (graph && !quad.graph.equals(graph)) {
+                    continue;
+                }
+                switch (quad.subject.termType) {
+                    case "BlankNode":
+                    case "NamedNode":
                         break;
-                    }
-                    lefts.push(either);
+                    default:
+                        continue;
                 }
-                // Doesn't appear to belong to any of the known object types, just assume the first
-                if (lefts.length === objectTypes.length) {
-                    return lefts[0];
+                if (identifierSet.has(quad.subject)) {
+                    continue;
                 }
-            }
-            return purify.Either.of(objects);
-        }
-        const resources = [];
-        for (const objectType of objectTypes) {
-            if (objectType.$fromRdfTypes.length === 0) {
-                continue;
-            }
-            for (const fromRdfType of objectType.$fromRdfTypes) {
-                for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
-                    if (!resources.some(({ resource: existingResource }) => existingResource.identifier.equals(resource.identifier))) {
-                        resources.push({ objectType, resource });
+                identifierSet.add(quad.subject);
+                // Eagerly eliminate the majority of resources that won't match the object types
+                const resource = resourceSet.resource(quad.subject);
+                for (const objectType of objectTypes) {
+                    if (objectType
+                        .$fromRdf(resource, { graph, objectSet: this })
+                        .ifRight((object) => {
+                        resources.push({ object, objectType, resource });
+                    })
+                        .isRight()) {
+                        break;
                     }
                 }
             }
         }
-        // Sort resources by identifier so limit and offset are deterministic
-        resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
+        if (sortResources) {
+            // 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, { objectSet: this });
-            if (either.isLeft()) {
-                return either;
+        for (let { object, objectType, resource } of resources) {
+            if (!object) {
+                let objectEither;
+                if (objectType) {
+                    objectEither = objectType.$fromRdf(resource, {
+                        graph,
+                        objectSet: this,
+                    });
+                }
+                else {
+                    objectEither = Left(new Error("no object types"));
+                    for (const tryObjectType of objectTypes) {
+                        objectEither = tryObjectType.$fromRdf(resource, {
+                            graph,
+                            objectSet: this,
+                        });
+                        if (objectEither.isRight()) {
+                            objectType = tryObjectType;
+                            break;
+                        }
+                    }
+                }
+                if (objectEither.isLeft()) {
+                    return objectEither;
+                }
+                object = objectEither.unsafeCoerce();
+            }
+            if (!objectType) {
+                throw new Error("objectType should be set here");
+            }
+            if (query?.filter && !objectType.$filter(query.filter, object)) {
+                continue;
             }
             if (objectI++ >= offset) {
-                objects.push(either.unsafeCoerce());
+                objects.push(object);
                 if (objects.length === limit) {
-                    return purify.Either.of(objects);
+                    return Right(objects);
                 }
             }
         }
-        return purify.Either.of(objects);
-    }
-    $objectUnionsCountSync(objectTypes, query) {
-        return this.$objectUnionIdentifiersSync(objectTypes, query).map((objects) => objects.length);
+        return Right(objects);
     }
 }
 //# sourceMappingURL=generated.js.map