@shaclmate/shacl-ast 3.0.1 → 3.0.3

package/dist/generated.js

@@ -1,7 +1,4 @@
-import { StoreFactory as _DatasetFactory, DataFactory as dataFactory, } from "n3";
-const datasetFactory = new _DatasetFactory();
-import * as purify from "purify-ts";
-import * as rdfjsResource from "rdfjs-resource";
+import { dataFactory, datasetFactory, purify, rdfjsResource, } from "@shaclmate/runtime";
 import { PropertyPath } from "./PropertyPath.js";
 export var $RdfVocabularies;
 (function ($RdfVocabularies) {
@@ -39,7 +36,7 @@ export var BaseShaclCoreShapeStatic;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
         }
@@ -54,7 +51,7 @@ export var BaseShaclCoreShapeStatic;
         }));
     }
     BaseShaclCoreShapeStatic.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $identifier = $resource.identifier;
@@ -92,42 +89,34 @@ export var BaseShaclCoreShapeStatic;
         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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -168,6 +157,34 @@ export var BaseShaclCoreShapeStatic;
         }
         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({
@@ -255,42 +272,34 @@ export var BaseShaclCoreShapeStatic;
         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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -308,7 +317,36 @@ export var BaseShaclCoreShapeStatic;
             objects: valueList,
             predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
             subject: $resource,
-        })).chain((values) => values.chainMap((value) => value.toString()))))
+        }))
+            .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))
@@ -340,42 +378,34 @@ export var BaseShaclCoreShapeStatic;
             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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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({
@@ -392,42 +422,34 @@ export var BaseShaclCoreShapeStatic;
             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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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({
@@ -472,42 +494,34 @@ export var BaseShaclCoreShapeStatic;
             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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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({
@@ -524,42 +538,34 @@ export var BaseShaclCoreShapeStatic;
             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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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({
@@ -668,6 +674,34 @@ export var BaseShaclCoreShapeStatic;
         }
         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);
+                }
+                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.patterns["identifier"],
+                subject: $resource,
+            })));
+        })
             .chain((values) => values.chainMap((value) => value.toString()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
@@ -737,126 +771,136 @@ export var BaseShaclCoreShapeStatic;
                 dataset: datasetFactory.dataset(),
             });
         const resource = resourceSet.mutableResource(_baseShaclCoreShape.$identifier, { mutateGraph });
-        resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], _baseShaclCoreShape.and.map((item) => item.length > 0
-            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], _baseShaclCoreShape.classes.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.comments["identifier"], _baseShaclCoreShape.comments.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], _baseShaclCoreShape.datatype);
-        resource.add(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], _baseShaclCoreShape.deactivated);
-        resource.add(BaseShaclCoreShapeStatic.$properties.flags["identifier"], _baseShaclCoreShape.flags.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], _baseShaclCoreShape.hasValues.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.in_["identifier"], _baseShaclCoreShape.in_.map((value) => value.length > 0
-            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], _baseShaclCoreShape.isDefinedBy);
-        resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], _baseShaclCoreShape.labels.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], _baseShaclCoreShape.languageIn.map((value) => value.length > 0
-            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], _baseShaclCoreShape.maxCount);
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], _baseShaclCoreShape.maxExclusive);
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], _baseShaclCoreShape.maxInclusive);
-        resource.add(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], _baseShaclCoreShape.maxLength);
-        resource.add(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], _baseShaclCoreShape.minCount);
-        resource.add(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], _baseShaclCoreShape.minExclusive);
-        resource.add(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], _baseShaclCoreShape.minInclusive);
-        resource.add(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], _baseShaclCoreShape.minLength);
-        resource.add(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], _baseShaclCoreShape.nodeKind);
-        resource.add(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], _baseShaclCoreShape.nodes.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.not["identifier"], _baseShaclCoreShape.not.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.or["identifier"], _baseShaclCoreShape.or.map((item) => item.length > 0
-            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], _baseShaclCoreShape.patterns.map((item) => item));
-        resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], _baseShaclCoreShape.xone.map((item) => item.length > 0
-            ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
+        resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], ..._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);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], ..._baseShaclCoreShape.classes.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) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], ..._baseShaclCoreShape.isDefinedBy.toList());
+        resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], ..._baseShaclCoreShape.labels.flatMap((item) => [item]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], ..._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);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], ..._baseShaclCoreShape.maxCount.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) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], ..._baseShaclCoreShape.patterns.flatMap((item) => [item]));
+        resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], ..._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);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
         return resource;
     }
     BaseShaclCoreShapeStatic.$toRdf = $toRdf;
@@ -939,38 +983,52 @@ export var ShaclCorePropertyShape;
     ShaclCorePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     ShaclCorePropertyShape.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
         }
         return ShaclCorePropertyShape.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclCorePropertyShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
-            languageIn: $languageIn,
             objectSet: $objectSet,
+            preferredLanguages: $preferredLanguages,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
             return $super0Either;
         }
         const $super0 = $super0Either.unsafeCoerce();
-        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyShape.$fromRdfType)) {
-            return $resource
+        if (!$ignoreRdfType) {
+            const $rdfTypeCheck = $resource
                 .value($RdfVocabularies.rdf.type)
                 .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`)));
+                .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);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(ShaclCorePropertyShape.$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/ns/shacl#PropertyShape)`));
+            });
+            if ($rdfTypeCheck.isLeft()) {
+                return $rdfTypeCheck;
+            }
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclCorePropertyShape";
@@ -1007,42 +1065,34 @@ export var ShaclCorePropertyShape;
             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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -1069,42 +1119,34 @@ export var ShaclCorePropertyShape;
         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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -1134,8 +1176,8 @@ export var ShaclCorePropertyShape;
             .chain((values) => values.chainMap((value) => value.toResource().chain((resource) => PropertyPath.$fromRdf(resource, {
             ...$context,
             ignoreRdfType: true,
-            languageIn: $languageIn,
             objectSet: $objectSet,
+            preferredLanguages: $preferredLanguages,
         }))))
             .chain((values) => values.head());
         if (_pathEither.isLeft()) {
@@ -1187,16 +1229,18 @@ export var ShaclCorePropertyShape;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCorePropertyShape"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
         }
-        resource.add(ShaclCorePropertyShape.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
-        resource.add(ShaclCorePropertyShape.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
-        resource.add(ShaclCorePropertyShape.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
-        resource.add(ShaclCorePropertyShape.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
-        resource.add(ShaclCorePropertyShape.$properties.order["identifier"], _shaclCorePropertyShape.order);
-        resource.add(ShaclCorePropertyShape.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
-            mutateGraph: mutateGraph,
-            resourceSet: resourceSet,
-        }));
-        resource.add(ShaclCorePropertyShape.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
+        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"], ...[
+            PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+                mutateGraph: mutateGraph,
+                resourceSet: resourceSet,
+            }).identifier,
+        ]);
+        resource.add(ShaclCorePropertyShape.$properties.uniqueLang["identifier"], ..._shaclCorePropertyShape.uniqueLang.toList().flat());
         return resource;
     }
     ShaclCorePropertyShape.$toRdf = $toRdf;
@@ -1240,68 +1284,74 @@ export var ShaclCorePropertyGroup;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = ShaclCorePropertyGroup.$Identifier || (ShaclCorePropertyGroup.$Identifier = {}));
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
         }
         return ShaclCorePropertyGroup.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclCorePropertyGroup.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
     // @ts-ignore
     ...$context }) {
-        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyGroup.$fromRdfType)) {
-            return $resource
+        if (!$ignoreRdfType) {
+            const $rdfTypeCheck = $resource
                 .value($RdfVocabularies.rdf.type)
                 .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`)));
+                .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);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(ShaclCorePropertyGroup.$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/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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -1315,42 +1365,34 @@ export var ShaclCorePropertyGroup;
         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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -1377,8 +1419,8 @@ export var ShaclCorePropertyGroup;
         if (!ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"));
         }
-        resource.add(ShaclCorePropertyGroup.$properties.comments["identifier"], _shaclCorePropertyGroup.comments.map((item) => item));
-        resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], _shaclCorePropertyGroup.labels.map((item) => item));
+        resource.add(ShaclCorePropertyGroup.$properties.comments["identifier"], ..._shaclCorePropertyGroup.comments.flatMap((item) => [item]));
+        resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], ..._shaclCorePropertyGroup.labels.flatMap((item) => [item]));
         return resource;
     }
     ShaclCorePropertyGroup.$toRdf = $toRdf;
@@ -1396,38 +1438,52 @@ export var ShaclCoreNodeShape;
     ShaclCoreNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     ShaclCoreNodeShape.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
         }
         return ShaclCoreNodeShape.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclCoreNodeShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
-            languageIn: $languageIn,
             objectSet: $objectSet,
+            preferredLanguages: $preferredLanguages,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
             return $super0Either;
         }
         const $super0 = $super0Either.unsafeCoerce();
-        if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCoreNodeShape.$fromRdfType)) {
-            return $resource
+        if (!$ignoreRdfType) {
+            const $rdfTypeCheck = $resource
                 .value($RdfVocabularies.rdf.type)
                 .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`)));
+                .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);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(ShaclCoreNodeShape.$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/ns/shacl#NodeShape)`));
+            });
+            if ($rdfTypeCheck.isLeft()) {
+                return $rdfTypeCheck;
+            }
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclCoreNodeShape";
@@ -1507,28 +1563,30 @@ export var ShaclCoreNodeShape;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCoreNodeShape"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
         }
-        resource.add(ShaclCoreNodeShape.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
-        resource.add(ShaclCoreNodeShape.$properties.ignoredProperties["identifier"], _shaclCoreNodeShape.ignoredProperties.map((value) => value.length > 0
-            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(ShaclCoreNodeShape.$properties.properties["identifier"], _shaclCoreNodeShape.properties.map((item) => item));
+        resource.add(ShaclCoreNodeShape.$properties.closed["identifier"], ..._shaclCoreNodeShape.closed.toList().flat());
+        resource.add(ShaclCoreNodeShape.$properties.ignoredProperties["identifier"], ..._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);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, ...[item]);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]));
+        resource.add(ShaclCoreNodeShape.$properties.properties["identifier"], ..._shaclCoreNodeShape.properties.flatMap((item) => [item]));
         return resource;
     }
     ShaclCoreNodeShape.$toRdf = $toRdf;
@@ -1560,68 +1618,74 @@ export var OwlOntology;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = OwlOntology.$Identifier || (OwlOntology.$Identifier = {}));
     function $fromRdf(resource, options) {
-        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
         }
         return OwlOntology.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     OwlOntology.$fromRdf = $fromRdf;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, 
     // @ts-ignore
     ...$context }) {
-        if (!$ignoreRdfType && !$resource.isInstanceOf(OwlOntology.$fromRdfType)) {
-            return $resource
+        if (!$ignoreRdfType) {
+            const $rdfTypeCheck = $resource
                 .value($RdfVocabularies.rdf.type)
                 .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => purify.Left(new Error(`${rdfjsResource.Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`)));
+                .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);
+                }
+                // 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();
-            const nonUniqueLanguageIn = $languageIn ?? [];
-            if (nonUniqueLanguageIn.length === 0) {
-                return purify.Either.of(literalValues);
-            }
-            let uniqueLanguageIn;
-            if (nonUniqueLanguageIn.length === 1) {
-                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-            }
-            else {
-                uniqueLanguageIn = [];
-                for (const languageIn of nonUniqueLanguageIn) {
-                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-                        uniqueLanguageIn.push(languageIn);
-                    }
-                }
-            }
-            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-            // Within a languageIn the literals may be in any order.
+            // 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 languageIn of uniqueLanguageIn) {
+            for (const preferredLanguage of $preferredLanguages) {
                 if (!filteredLiteralValues) {
-                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                    filteredLiteralValues = literalValues.filter((value) => value.language === preferredLanguage);
                 }
                 else {
                     filteredLiteralValues = filteredLiteralValues.concat(...literalValues
-                        .filter((value) => value.language === languageIn)
+                        .filter((value) => value.language === preferredLanguage)
                         .toArray());
                 }
             }
-            return purify.Either.of(filteredLiteralValues);
+            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,
@@ -1651,7 +1715,7 @@ export var OwlOntology;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#OwlOntology"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
         }
-        resource.add(OwlOntology.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
+        resource.add(OwlOntology.$properties.labels["identifier"], ..._owlOntology.labels.flatMap((item) => [item]));
         return resource;
     }
     OwlOntology.$toRdf = $toRdf;
@@ -1697,6 +1761,68 @@ export var ShaclCoreShape;
     }
     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);
+    }
+    shaclCoreShapeIdentifiers(query) {
+        return this.$delegate.shaclCoreShapeIdentifiers(query);
+    }
+    shaclCoreShapes(query) {
+        return this.$delegate.shaclCoreShapes(query);
+    }
+    shaclCoreShapesCount(query) {
+        return this.$delegate.shaclCoreShapesCount(query);
+    }
+}
 export class $RdfjsDatasetObjectSet {
     resourceSet;
     constructor({ dataset }) {
@@ -1714,19 +1840,28 @@ export class $RdfjsDatasetObjectSet {
         return this.owlOntologyIdentifiersSync(query);
     }
     owlOntologyIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(OwlOntology, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: OwlOntology.$fromRdf,
+            $fromRdfTypes: [OwlOntology.$fromRdfType],
+        }, query);
     }
     async owlOntologies(query) {
         return this.owlOntologiesSync(query);
     }
     owlOntologiesSync(query) {
-        return this.$objectsSync(OwlOntology, query);
+        return this.$objectsSync({
+            $fromRdf: OwlOntology.$fromRdf,
+            $fromRdfTypes: [OwlOntology.$fromRdfType],
+        }, query);
     }
     async owlOntologiesCount(query) {
         return this.owlOntologiesCountSync(query);
     }
     owlOntologiesCountSync(query) {
-        return this.$objectsCountSync(OwlOntology, query);
+        return this.$objectsCountSync({
+            $fromRdf: OwlOntology.$fromRdf,
+            $fromRdfTypes: [OwlOntology.$fromRdfType],
+        }, query);
     }
     async shaclCoreNodeShape(identifier) {
         return this.shaclCoreNodeShapeSync(identifier);
@@ -1740,19 +1875,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreNodeShapeIdentifiersSync(query);
     }
     shaclCoreNodeShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclCoreNodeShape, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclCoreNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclCoreNodeShapes(query) {
         return this.shaclCoreNodeShapesSync(query);
     }
     shaclCoreNodeShapesSync(query) {
-        return this.$objectsSync(ShaclCoreNodeShape, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclCoreNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclCoreNodeShapesCount(query) {
         return this.shaclCoreNodeShapesCountSync(query);
     }
     shaclCoreNodeShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclCoreNodeShape, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclCoreNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyGroup(identifier) {
         return this.shaclCorePropertyGroupSync(identifier);
@@ -1766,19 +1910,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCorePropertyGroupIdentifiersSync(query);
     }
     shaclCorePropertyGroupIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclCorePropertyGroup, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyGroups(query) {
         return this.shaclCorePropertyGroupsSync(query);
     }
     shaclCorePropertyGroupsSync(query) {
-        return this.$objectsSync(ShaclCorePropertyGroup, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyGroupsCount(query) {
         return this.shaclCorePropertyGroupsCountSync(query);
     }
     shaclCorePropertyGroupsCountSync(query) {
-        return this.$objectsCountSync(ShaclCorePropertyGroup, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyShape(identifier) {
         return this.shaclCorePropertyShapeSync(identifier);
@@ -1792,19 +1945,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCorePropertyShapeIdentifiersSync(query);
     }
     shaclCorePropertyShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclCorePropertyShape, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclCorePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyShapes(query) {
         return this.shaclCorePropertyShapesSync(query);
     }
     shaclCorePropertyShapesSync(query) {
-        return this.$objectsSync(ShaclCorePropertyShape, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclCorePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclCorePropertyShapesCount(query) {
         return this.shaclCorePropertyShapesCountSync(query);
     }
     shaclCorePropertyShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclCorePropertyShape, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclCorePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclCoreShape(identifier) {
         return this.shaclCoreShapeSync(identifier);
@@ -1818,19 +1980,46 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreShapeIdentifiersSync(query);
     }
     shaclCoreShapeIdentifiersSync(query) {
-        return this.$objectUnionIdentifiersSync([ShaclCoreNodeShape, ShaclCorePropertyShape], query);
+        return this.$objectUnionIdentifiersSync([
+            {
+                $fromRdf: ShaclCoreNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShape.$fromRdf,
+                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+            },
+        ], query);
     }
     async shaclCoreShapes(query) {
         return this.shaclCoreShapesSync(query);
     }
     shaclCoreShapesSync(query) {
-        return this.$objectUnionsSync([ShaclCoreNodeShape, ShaclCorePropertyShape], query);
+        return this.$objectUnionsSync([
+            {
+                $fromRdf: ShaclCoreNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShape.$fromRdf,
+                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+            },
+        ], query);
     }
     async shaclCoreShapesCount(query) {
         return this.shaclCoreShapesCountSync(query);
     }
     shaclCoreShapesCountSync(query) {
-        return this.$objectUnionsCountSync([ShaclCoreNodeShape, ShaclCorePropertyShape], query);
+        return this.$objectUnionsCountSync([
+            {
+                $fromRdf: ShaclCoreNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShape.$fromRdf,
+                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+            },
+        ], query);
     }
     $objectIdentifiersSync(objectType, query) {
         return this.$objectsSync(objectType, query).map((objects) => objects.map((object) => object.$identifier));
@@ -1882,12 +2071,17 @@ export class $RdfjsDatasetObjectSet {
             }
             return purify.Either.of(objects);
         }
-        if (!objectType.$fromRdfType) {
+        if (objectType.$fromRdfTypes.length === 0) {
             return purify.Either.of([]);
         }
-        const resources = [
-            ...this.resourceSet.instancesOf(objectType.$fromRdfType),
-        ];
+        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);
+                }
+            }
+        }
         // Sort resources by identifier so limit and offset are deterministic
         resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
         const objects = [];
@@ -1970,11 +2164,15 @@ export class $RdfjsDatasetObjectSet {
         }
         const resources = [];
         for (const objectType of objectTypes) {
-            if (!objectType.$fromRdfType) {
+            if (objectType.$fromRdfTypes.length === 0) {
                 continue;
             }
-            for (const resource of this.resourceSet.instancesOf(objectType.$fromRdfType)) {
-                resources.push({ objectType, resource });
+            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 });
+                    }
+                }
             }
         }
         // Sort resources by identifier so limit and offset are deterministic