@shaclmate/compiler 3.0.2 → 3.0.4

package/dist/input/generated.js

@@ -1,5 +1,6 @@
-import { StoreFactory as _DatasetFactory, DataFactory as dataFactory, } from "n3";
+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";
@@ -39,7 +40,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 +55,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 +93,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 +161,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 +276,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 +321,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 +382,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 +426,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 +498,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 +542,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 +678,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 +775,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,7 +987,7 @@ export var ShaclCorePropertyShapeStatic;
     ShaclCorePropertyShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     ShaclCorePropertyShapeStatic.$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 });
         }
@@ -950,31 +998,45 @@ export var ShaclCorePropertyShapeStatic;
         }).altLazy(() => ShaclCorePropertyShapeStatic.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         }));
     }
     ShaclCorePropertyShapeStatic.$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(ShaclCorePropertyShapeStatic.$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(ShaclCorePropertyShapeStatic.$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";
@@ -1011,42 +1073,34 @@ export var ShaclCorePropertyShapeStatic;
             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: ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"],
+                subject: $resource,
+            })));
         })
+            .chain((values) => values.chainMap((value) => value.toLiteral()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
             object: valuesArray,
@@ -1073,42 +1127,34 @@ export var ShaclCorePropertyShapeStatic;
         const groups = _groupsEither.unsafeCoerce();
         const _namesEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$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: ShaclCorePropertyShapeStatic.$properties.names["identifier"],
+                subject: $resource,
+            })));
         })
+            .chain((values) => values.chainMap((value) => value.toLiteral()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
             object: valuesArray,
@@ -1138,8 +1184,8 @@ export var ShaclCorePropertyShapeStatic;
             .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()) {
@@ -1191,16 +1237,18 @@ export var ShaclCorePropertyShapeStatic;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCorePropertyShape"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
         }
-        resource.add(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
-        resource.add(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
-        resource.add(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
-        resource.add(ShaclCorePropertyShapeStatic.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
-        resource.add(ShaclCorePropertyShapeStatic.$properties.order["identifier"], _shaclCorePropertyShape.order);
-        resource.add(ShaclCorePropertyShapeStatic.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
-            mutateGraph: mutateGraph,
-            resourceSet: resourceSet,
-        }));
-        resource.add(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
+        resource.add(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], ..._shaclCorePropertyShape.defaultValue.toList());
+        resource.add(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], ..._shaclCorePropertyShape.descriptions.flatMap((item) => [item]));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], ..._shaclCorePropertyShape.groups.flatMap((item) => [item]));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.names["identifier"], ..._shaclCorePropertyShape.names.flatMap((item) => [item]));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.order["identifier"], ..._shaclCorePropertyShape.order.toList());
+        resource.add(ShaclCorePropertyShapeStatic.$properties.path["identifier"], ...[
+            PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+                mutateGraph: mutateGraph,
+                resourceSet: resourceSet,
+            }).identifier,
+        ]);
+        resource.add(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], ..._shaclCorePropertyShape.uniqueLang.toList().flat());
         return resource;
     }
     ShaclCorePropertyShapeStatic.$toRdf = $toRdf;
@@ -1234,38 +1282,52 @@ export var ShaclmatePropertyShape;
     ShaclmatePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     ShaclmatePropertyShape.$Identifier = ShaclCorePropertyShapeStatic.$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 ShaclmatePropertyShape.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclmatePropertyShape.$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 = ShaclCorePropertyShapeStatic.$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(ShaclmatePropertyShape.$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(ShaclmatePropertyShape.$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 = "ShaclmatePropertyShape";
@@ -1298,6 +1360,34 @@ export var ShaclmatePropertyShape;
         }
         const mutable = _mutableEither.unsafeCoerce();
         const _nameEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.name["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: ShaclmateNodeShape.$properties.name["identifier"],
+                subject: $resource,
+            })));
+        })
             .chain((values) => values.chainMap((value) => value.toString()))
             .map((values) => values.length > 0
             ? values.map((value) => purify.Maybe.of(value))
@@ -1394,12 +1484,12 @@ export var ShaclmatePropertyShape;
         if (!ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
         }
-        resource.add(ShaclmatePropertyShape.$properties.lazy["identifier"], _shaclmatePropertyShape.lazy);
-        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmatePropertyShape.mutable);
-        resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmatePropertyShape.name);
-        resource.add(ShaclmatePropertyShape.$properties.stub["identifier"], _shaclmatePropertyShape.stub);
-        resource.add(ShaclmatePropertyShape.$properties.visibility["identifier"], _shaclmatePropertyShape.visibility);
-        resource.add(ShaclmatePropertyShape.$properties.widen["identifier"], _shaclmatePropertyShape.widen);
+        resource.add(ShaclmatePropertyShape.$properties.lazy["identifier"], ..._shaclmatePropertyShape.lazy.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], ..._shaclmatePropertyShape.mutable.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.name["identifier"], ..._shaclmatePropertyShape.name.toList());
+        resource.add(ShaclmatePropertyShape.$properties.stub["identifier"], ..._shaclmatePropertyShape.stub.toList());
+        resource.add(ShaclmatePropertyShape.$properties.visibility["identifier"], ..._shaclmatePropertyShape.visibility.toList());
+        resource.add(ShaclmatePropertyShape.$properties.widen["identifier"], ..._shaclmatePropertyShape.widen.toList().flat());
         return resource;
     }
     ShaclmatePropertyShape.$toRdf = $toRdf;
@@ -1440,7 +1530,7 @@ export var OwlOntologyStatic;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = OwlOntologyStatic.$Identifier || (OwlOntologyStatic.$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 });
         }
@@ -1451,61 +1541,67 @@ export var OwlOntologyStatic;
         }).altLazy(() => OwlOntologyStatic.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         }));
     }
     OwlOntologyStatic.$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(OwlOntologyStatic.$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(OwlOntologyStatic.$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(OwlOntologyStatic.$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: OwlOntologyStatic.$properties.labels["identifier"],
+                subject: $resource,
+            })));
         })
+            .chain((values) => values.chainMap((value) => value.toLiteral()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
             object: valuesArray,
@@ -1535,7 +1631,7 @@ export var OwlOntologyStatic;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#OwlOntology"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
         }
-        resource.add(OwlOntologyStatic.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
+        resource.add(OwlOntologyStatic.$properties.labels["identifier"], ..._owlOntology.labels.flatMap((item) => [item]));
         return resource;
     }
     OwlOntologyStatic.$toRdf = $toRdf;
@@ -1550,38 +1646,52 @@ export var ShaclmateOntology;
     ShaclmateOntology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
     ShaclmateOntology.$Identifier = OwlOntologyStatic.$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 ShaclmateOntology.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclmateOntology.$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 = OwlOntologyStatic.$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(ShaclmateOntology.$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(ShaclmateOntology.$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 = "ShaclmateOntology";
@@ -1676,6 +1786,34 @@ export var ShaclmateOntology;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
         const _tsImportsEither = purify.Either.of($resource.values(ShaclmateOntology.$properties.tsImports["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: ShaclmateNodeShape.$properties.tsImports["identifier"],
+                subject: $resource,
+            })));
+        })
             .chain((values) => values.chainMap((value) => value.toString()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
@@ -1745,10 +1883,10 @@ export var ShaclmateOntology;
         if (!ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
         }
-        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateOntology.tsFeatureExcludes.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateOntology.tsFeatureIncludes.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateOntology.tsImports.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateOntology.tsObjectDeclarationType);
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], ..._shaclmateOntology.tsFeatureExcludes.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], ..._shaclmateOntology.tsFeatureIncludes.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], ..._shaclmateOntology.tsImports.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], ..._shaclmateOntology.tsObjectDeclarationType.toList());
         return resource;
     }
     ShaclmateOntology.$toRdf = $toRdf;
@@ -1773,7 +1911,7 @@ export var ShaclCoreNodeShapeStatic;
     ShaclCoreNodeShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     ShaclCoreNodeShapeStatic.$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 });
         }
@@ -1784,31 +1922,45 @@ export var ShaclCoreNodeShapeStatic;
         }).altLazy(() => ShaclCoreNodeShapeStatic.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         }));
     }
     ShaclCoreNodeShapeStatic.$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(ShaclCoreNodeShapeStatic.$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(ShaclCoreNodeShapeStatic.$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";
@@ -1888,28 +2040,30 @@ export var ShaclCoreNodeShapeStatic;
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCoreNodeShape"));
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
         }
-        resource.add(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
-        resource.add(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], _shaclCoreNodeShape.ignoredProperties.map((value) => value.length > 0
-            ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                if (itemIndex === 0) {
-                    currentSubListResource = listResource;
-                }
-                else {
-                    const newSubListResource = resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph });
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier);
-                    currentSubListResource = newSubListResource;
-                }
-                currentSubListResource.add($RdfVocabularies.rdf.first, item);
-                if (itemIndex + 1 === list.length) {
-                    currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil);
-                }
-                return { currentSubListResource, listResource };
-            }, {
-                currentSubListResource: null,
-                listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
-            }).listResource.identifier
-            : $RdfVocabularies.rdf.nil));
-        resource.add(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], _shaclCoreNodeShape.properties.map((item) => item));
+        resource.add(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], ..._shaclCoreNodeShape.closed.toList().flat());
+        resource.add(ShaclCoreNodeShapeStatic.$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(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], ..._shaclCoreNodeShape.properties.flatMap((item) => [item]));
         return resource;
     }
     ShaclCoreNodeShapeStatic.$toRdf = $toRdf;
@@ -1931,38 +2085,52 @@ export var ShaclmateNodeShape;
     ShaclmateNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     ShaclmateNodeShape.$Identifier = ShaclCoreNodeShapeStatic.$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 ShaclmateNodeShape.$propertiesFromRdf({
             ...context,
             ignoreRdfType,
-            languageIn,
             objectSet,
+            preferredLanguages,
             resource,
         });
     }
     ShaclmateNodeShape.$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 = ShaclCoreNodeShapeStatic.$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(ShaclmateNodeShape.$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(ShaclmateNodeShape.$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 = "ShaclmateNodeShape";
@@ -2069,6 +2237,34 @@ export var ShaclmateNodeShape;
         }
         const mutable = _mutableEither.unsafeCoerce();
         const _nameEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.name["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: ShaclmateNodeShape.$properties.name["identifier"],
+                subject: $resource,
+            })));
+        })
             .chain((values) => values.chainMap((value) => value.toString()))
             .map((values) => values.length > 0
             ? values.map((value) => purify.Maybe.of(value))
@@ -2202,6 +2398,34 @@ export var ShaclmateNodeShape;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
         const _tsImportsEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.tsImports["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: ShaclmateNodeShape.$properties.tsImports["identifier"],
+                subject: $resource,
+            })));
+        })
             .chain((values) => values.chainMap((value) => value.toString()))
             .map((values) => values.toArray())
             .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
@@ -2280,19 +2504,19 @@ export var ShaclmateNodeShape;
         if (!ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
         }
-        resource.add(ShaclmateNodeShape.$properties.abstract["identifier"], _shaclmateNodeShape.abstract);
-        resource.add(ShaclmateNodeShape.$properties.export_["identifier"], _shaclmateNodeShape.export_);
-        resource.add(ShaclmateNodeShape.$properties.extern["identifier"], _shaclmateNodeShape.extern);
-        resource.add(ShaclmateNodeShape.$properties.fromRdfType["identifier"], _shaclmateNodeShape.fromRdfType);
-        resource.add(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], _shaclmateNodeShape.identifierMintingStrategy);
-        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmateNodeShape.mutable);
-        resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmateNodeShape.name);
-        resource.add(ShaclmateNodeShape.$properties.rdfType["identifier"], _shaclmateNodeShape.rdfType);
-        resource.add(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], _shaclmateNodeShape.toRdfTypes.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateNodeShape.tsFeatureExcludes.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateNodeShape.tsFeatureIncludes.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateNodeShape.tsImports.map((item) => item));
-        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateNodeShape.tsObjectDeclarationType);
+        resource.add(ShaclmateNodeShape.$properties.abstract["identifier"], ..._shaclmateNodeShape.abstract.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.export_["identifier"], ..._shaclmateNodeShape.export_.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.extern["identifier"], ..._shaclmateNodeShape.extern.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.fromRdfType["identifier"], ..._shaclmateNodeShape.fromRdfType.toList());
+        resource.add(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], ..._shaclmateNodeShape.identifierMintingStrategy.toList());
+        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], ..._shaclmateNodeShape.mutable.toList().flat());
+        resource.add(ShaclmateNodeShape.$properties.name["identifier"], ..._shaclmateNodeShape.name.toList());
+        resource.add(ShaclmateNodeShape.$properties.rdfType["identifier"], ..._shaclmateNodeShape.rdfType.toList());
+        resource.add(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], ..._shaclmateNodeShape.toRdfTypes.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], ..._shaclmateNodeShape.tsFeatureExcludes.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], ..._shaclmateNodeShape.tsFeatureIncludes.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], ..._shaclmateNodeShape.tsImports.flatMap((item) => [item]));
+        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], ..._shaclmateNodeShape.tsObjectDeclarationType.toList());
         return resource;
     }
     ShaclmateNodeShape.$toRdf = $toRdf;
@@ -2354,68 +2578,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,
@@ -2429,42 +2659,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,
@@ -2491,8 +2713,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;
@@ -2580,6 +2802,116 @@ export var ShaclmateShape;
     }
     ShaclmateShape.$toRdf = $toRdf;
 })(ShaclmateShape || (ShaclmateShape = {}));
+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);
+    }
+    shaclmateNodeShape(identifier) {
+        return this.$delegate.shaclmateNodeShape(identifier);
+    }
+    shaclmateNodeShapeIdentifiers(query) {
+        return this.$delegate.shaclmateNodeShapeIdentifiers(query);
+    }
+    shaclmateNodeShapes(query) {
+        return this.$delegate.shaclmateNodeShapes(query);
+    }
+    shaclmateNodeShapesCount(query) {
+        return this.$delegate.shaclmateNodeShapesCount(query);
+    }
+    shaclmateOntology(identifier) {
+        return this.$delegate.shaclmateOntology(identifier);
+    }
+    shaclmateOntologyIdentifiers(query) {
+        return this.$delegate.shaclmateOntologyIdentifiers(query);
+    }
+    shaclmateOntologies(query) {
+        return this.$delegate.shaclmateOntologies(query);
+    }
+    shaclmateOntologiesCount(query) {
+        return this.$delegate.shaclmateOntologiesCount(query);
+    }
+    shaclmatePropertyShape(identifier) {
+        return this.$delegate.shaclmatePropertyShape(identifier);
+    }
+    shaclmatePropertyShapeIdentifiers(query) {
+        return this.$delegate.shaclmatePropertyShapeIdentifiers(query);
+    }
+    shaclmatePropertyShapes(query) {
+        return this.$delegate.shaclmatePropertyShapes(query);
+    }
+    shaclmatePropertyShapesCount(query) {
+        return this.$delegate.shaclmatePropertyShapesCount(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);
+    }
+    shaclmateShape(identifier) {
+        return this.$delegate.shaclmateShape(identifier);
+    }
+    shaclmateShapeIdentifiers(query) {
+        return this.$delegate.shaclmateShapeIdentifiers(query);
+    }
+    shaclmateShapes(query) {
+        return this.$delegate.shaclmateShapes(query);
+    }
+    shaclmateShapesCount(query) {
+        return this.$delegate.shaclmateShapesCount(query);
+    }
+}
 export class $RdfjsDatasetObjectSet {
     resourceSet;
     constructor({ dataset }) {
@@ -2597,19 +2929,37 @@ export class $RdfjsDatasetObjectSet {
         return this.owlOntologyIdentifiersSync(query);
     }
     owlOntologyIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(OwlOntologyStatic, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: OwlOntologyStatic.$fromRdf,
+            $fromRdfTypes: [
+                OwlOntologyStatic.$fromRdfType,
+                ShaclmateOntology.$fromRdfType,
+            ],
+        }, query);
     }
     async owlOntologies(query) {
         return this.owlOntologiesSync(query);
     }
     owlOntologiesSync(query) {
-        return this.$objectsSync(OwlOntologyStatic, query);
+        return this.$objectsSync({
+            $fromRdf: OwlOntologyStatic.$fromRdf,
+            $fromRdfTypes: [
+                OwlOntologyStatic.$fromRdfType,
+                ShaclmateOntology.$fromRdfType,
+            ],
+        }, query);
     }
     async owlOntologiesCount(query) {
         return this.owlOntologiesCountSync(query);
     }
     owlOntologiesCountSync(query) {
-        return this.$objectsCountSync(OwlOntologyStatic, query);
+        return this.$objectsCountSync({
+            $fromRdf: OwlOntologyStatic.$fromRdf,
+            $fromRdfTypes: [
+                OwlOntologyStatic.$fromRdfType,
+                ShaclmateOntology.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCoreNodeShape(identifier) {
         return this.shaclCoreNodeShapeSync(identifier);
@@ -2623,19 +2973,37 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreNodeShapeIdentifiersSync(query);
     }
     shaclCoreNodeShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclCoreNodeShapeStatic, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCoreNodeShapeStatic.$fromRdfType,
+                ShaclmateNodeShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCoreNodeShapes(query) {
         return this.shaclCoreNodeShapesSync(query);
     }
     shaclCoreNodeShapesSync(query) {
-        return this.$objectsSync(ShaclCoreNodeShapeStatic, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCoreNodeShapeStatic.$fromRdfType,
+                ShaclmateNodeShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCoreNodeShapesCount(query) {
         return this.shaclCoreNodeShapesCountSync(query);
     }
     shaclCoreNodeShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclCoreNodeShapeStatic, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCoreNodeShapeStatic.$fromRdfType,
+                ShaclmateNodeShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCorePropertyGroup(identifier) {
         return this.shaclCorePropertyGroupSync(identifier);
@@ -2649,19 +3017,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);
@@ -2675,19 +3052,37 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCorePropertyShapeIdentifiersSync(query);
     }
     shaclCorePropertyShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclCorePropertyShapeStatic, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCorePropertyShapeStatic.$fromRdfType,
+                ShaclmatePropertyShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCorePropertyShapes(query) {
         return this.shaclCorePropertyShapesSync(query);
     }
     shaclCorePropertyShapesSync(query) {
-        return this.$objectsSync(ShaclCorePropertyShapeStatic, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCorePropertyShapeStatic.$fromRdfType,
+                ShaclmatePropertyShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclCorePropertyShapesCount(query) {
         return this.shaclCorePropertyShapesCountSync(query);
     }
     shaclCorePropertyShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclCorePropertyShapeStatic, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+            $fromRdfTypes: [
+                ShaclCorePropertyShapeStatic.$fromRdfType,
+                ShaclmatePropertyShape.$fromRdfType,
+            ],
+        }, query);
     }
     async shaclmateNodeShape(identifier) {
         return this.shaclmateNodeShapeSync(identifier);
@@ -2701,19 +3096,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclmateNodeShapeIdentifiersSync(query);
     }
     shaclmateNodeShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclmateNodeShape, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclmateNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclmateNodeShapes(query) {
         return this.shaclmateNodeShapesSync(query);
     }
     shaclmateNodeShapesSync(query) {
-        return this.$objectsSync(ShaclmateNodeShape, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclmateNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclmateNodeShapesCount(query) {
         return this.shaclmateNodeShapesCountSync(query);
     }
     shaclmateNodeShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclmateNodeShape, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclmateNodeShape.$fromRdf,
+            $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+        }, query);
     }
     async shaclmateOntology(identifier) {
         return this.shaclmateOntologySync(identifier);
@@ -2727,19 +3131,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclmateOntologyIdentifiersSync(query);
     }
     shaclmateOntologyIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclmateOntology, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclmateOntology.$fromRdf,
+            $fromRdfTypes: [ShaclmateOntology.$fromRdfType],
+        }, query);
     }
     async shaclmateOntologies(query) {
         return this.shaclmateOntologiesSync(query);
     }
     shaclmateOntologiesSync(query) {
-        return this.$objectsSync(ShaclmateOntology, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclmateOntology.$fromRdf,
+            $fromRdfTypes: [ShaclmateOntology.$fromRdfType],
+        }, query);
     }
     async shaclmateOntologiesCount(query) {
         return this.shaclmateOntologiesCountSync(query);
     }
     shaclmateOntologiesCountSync(query) {
-        return this.$objectsCountSync(ShaclmateOntology, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclmateOntology.$fromRdf,
+            $fromRdfTypes: [ShaclmateOntology.$fromRdfType],
+        }, query);
     }
     async shaclmatePropertyShape(identifier) {
         return this.shaclmatePropertyShapeSync(identifier);
@@ -2753,19 +3166,28 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclmatePropertyShapeIdentifiersSync(query);
     }
     shaclmatePropertyShapeIdentifiersSync(query) {
-        return this.$objectIdentifiersSync(ShaclmatePropertyShape, query);
+        return this.$objectIdentifiersSync({
+            $fromRdf: ShaclmatePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclmatePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclmatePropertyShapes(query) {
         return this.shaclmatePropertyShapesSync(query);
     }
     shaclmatePropertyShapesSync(query) {
-        return this.$objectsSync(ShaclmatePropertyShape, query);
+        return this.$objectsSync({
+            $fromRdf: ShaclmatePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclmatePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclmatePropertyShapesCount(query) {
         return this.shaclmatePropertyShapesCountSync(query);
     }
     shaclmatePropertyShapesCountSync(query) {
-        return this.$objectsCountSync(ShaclmatePropertyShape, query);
+        return this.$objectsCountSync({
+            $fromRdf: ShaclmatePropertyShape.$fromRdf,
+            $fromRdfTypes: [ShaclmatePropertyShape.$fromRdfType],
+        }, query);
     }
     async shaclCoreShape(identifier) {
         return this.shaclCoreShapeSync(identifier);
@@ -2779,19 +3201,64 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclCoreShapeIdentifiersSync(query);
     }
     shaclCoreShapeIdentifiersSync(query) {
-        return this.$objectUnionIdentifiersSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionIdentifiersSync([
+            {
+                $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCoreNodeShapeStatic.$fromRdfType,
+                    ShaclmateNodeShape.$fromRdfType,
+                ],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     async shaclCoreShapes(query) {
         return this.shaclCoreShapesSync(query);
     }
     shaclCoreShapesSync(query) {
-        return this.$objectUnionsSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionsSync([
+            {
+                $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCoreNodeShapeStatic.$fromRdfType,
+                    ShaclmateNodeShape.$fromRdfType,
+                ],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     async shaclCoreShapesCount(query) {
         return this.shaclCoreShapesCountSync(query);
     }
     shaclCoreShapesCountSync(query) {
-        return this.$objectUnionsCountSync([ShaclCoreNodeShapeStatic, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionsCountSync([
+            {
+                $fromRdf: ShaclCoreNodeShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCoreNodeShapeStatic.$fromRdfType,
+                    ShaclmateNodeShape.$fromRdfType,
+                ],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     async shaclmateShape(identifier) {
         return this.shaclmateShapeSync(identifier);
@@ -2805,19 +3272,55 @@ export class $RdfjsDatasetObjectSet {
         return this.shaclmateShapeIdentifiersSync(query);
     }
     shaclmateShapeIdentifiersSync(query) {
-        return this.$objectUnionIdentifiersSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionIdentifiersSync([
+            {
+                $fromRdf: ShaclmateNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     async shaclmateShapes(query) {
         return this.shaclmateShapesSync(query);
     }
     shaclmateShapesSync(query) {
-        return this.$objectUnionsSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionsSync([
+            {
+                $fromRdf: ShaclmateNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     async shaclmateShapesCount(query) {
         return this.shaclmateShapesCountSync(query);
     }
     shaclmateShapesCountSync(query) {
-        return this.$objectUnionsCountSync([ShaclmateNodeShape, ShaclCorePropertyShapeStatic], query);
+        return this.$objectUnionsCountSync([
+            {
+                $fromRdf: ShaclmateNodeShape.$fromRdf,
+                $fromRdfTypes: [ShaclmateNodeShape.$fromRdfType],
+            },
+            {
+                $fromRdf: ShaclCorePropertyShapeStatic.$fromRdf,
+                $fromRdfTypes: [
+                    ShaclCorePropertyShapeStatic.$fromRdfType,
+                    ShaclmatePropertyShape.$fromRdfType,
+                ],
+            },
+        ], query);
     }
     $objectIdentifiersSync(objectType, query) {
         return this.$objectsSync(objectType, query).map((objects) => objects.map((object) => object.$identifier));
@@ -2869,12 +3372,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 = [];
@@ -2957,11 +3465,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