@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/input/generated.js

@@ -1,7 +1,7 @@
 import dataFactory from "@rdfjs/data-model";
 import datasetFactory from "@rdfjs/dataset";
 import { Either, Left, Maybe, Right } from "purify-ts";
-import { LiteralFactory, PropertyPath, Resource, ResourceSet, } from "rdfjs-resource";
+import { LiteralFactory, PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "rdfjs-resource";
 function $filterArray(filterItem) {
     return (filter, values) => {
         for (const value of values) {
@@ -163,6 +163,19 @@ class $IdentifierSet {
     }
 }
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
+export var $PropertyPath;
+(function ($PropertyPath) {
+    function $filter(_filter, _value) {
+        return true;
+    }
+    $PropertyPath.$filter = $filter;
+    $PropertyPath.$fromRdfResource = RdfjsResourcePropertyPath.fromResource;
+    $PropertyPath.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => $PropertyPath.$fromRdfResource(resource, options))));
+    $PropertyPath.$schema = {};
+    $PropertyPath.$toRdfResource = RdfjsResourcePropertyPath.toResource;
+})($PropertyPath || ($PropertyPath = {}));
 var $RdfVocabularies;
 (function ($RdfVocabularies) {
     let rdf;
@@ -337,7 +350,7 @@ export var PropertyShape;
             return false;
         }
         if (filter.path !== undefined &&
-            !PropertyPath.$filter(filter.path, value.path)) {
+            !$PropertyPath.$filter(filter.path, value.path)) {
             return false;
         }
         if (filter.patterns !== undefined &&
@@ -363,20 +376,22 @@ export var PropertyShape;
         return true;
     }
     PropertyShape.$filter = $filter;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    PropertyShape.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return PropertyShape.$propertiesFromRdf({
+        return PropertyShape.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
-    }
-    PropertyShape.$fromRdf = $fromRdf;
+    };
+    PropertyShape.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyShape.$fromRdfResource(resource, options))));
     PropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     function isPropertyShape(object) {
         switch (object.$type) {
@@ -387,10 +402,10 @@ export var PropertyShape;
         }
     }
     PropertyShape.isPropertyShape = isPropertyShape;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
+    PropertyShape.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
@@ -399,95 +414,95 @@ export var PropertyShape;
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(PropertyShape.$fromRdfType, {
-                    graph: $parameters.graph,
+                if ($resource.isInstanceOf(PropertyShape.$fromRdfType, {
+                    graph: _$options.graph,
                 })) {
                     return Right(true);
                 }
-                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
             })
             : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
             dataFactory: dataFactory,
-            focusResource: $parameters.resource,
+            focusResource: $resource,
             propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
+            term: $resource.identifier,
         }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
             .chain((values) => values.head())
             .chain(($identifier) => Right("PropertyShape").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.and,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
+                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.and.path,
                 values: valueList.toArray(),
             })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.and.path,
                 value: valuesArray,
             })),
         }).chain((and) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.classes,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.classes.path,
                 value: valuesArray,
             })),
         }).chain((classes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.comments,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.comments.path,
                 value: valuesArray,
             })),
         }).chain((comments) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.datatype,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties.datatype
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((datatype) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.deactivated,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties.deactivated
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((deactivated) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.defaultValue,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
@@ -499,7 +514,7 @@ export var PropertyShape;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
+                            focusResource: $resource,
                             propertyPath: PropertyShape.$schema.properties
                                 .defaultValue.path,
                         }));
@@ -508,55 +523,55 @@ export var PropertyShape;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties
                         .defaultValue.path,
                     value: Maybe.empty(),
                 })),
         }).chain((defaultValue) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.descriptions,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties
                     .descriptions.path,
                 value: valuesArray,
             })),
         }).chain((descriptions) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.flags,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.flags
                     .path,
                 value: valuesArray,
             })),
         }).chain((flags) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.groups,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.groups
                     .path,
                 value: valuesArray,
             })),
         }).chain((groups) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.hasValues,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
@@ -568,7 +583,7 @@ export var PropertyShape;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
+                            focusResource: $resource,
                             propertyPath: PropertyShape.$schema
                                 .properties.hasValues
                                 .path,
@@ -577,21 +592,21 @@ export var PropertyShape;
             })))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties
                     .hasValues.path,
                 value: valuesArray,
             })),
         }).chain((hasValues) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.in_,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties
                     .in_.path,
                 values: valueList.toArray(),
@@ -604,7 +619,7 @@ export var PropertyShape;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
+                            focusResource: $resource,
                             propertyPath: PropertyShape
                                 .$schema
                                 .properties.in_
@@ -616,109 +631,109 @@ export var PropertyShape;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties
                         .in_.path,
                     value: Maybe.empty(),
                 })),
         }).chain((in_) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.isDefinedBy,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema
                         .properties.isDefinedBy
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((isDefinedBy) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.labels,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties
                     .labels.path,
                 value: valuesArray,
             })),
         }).chain((labels) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.languageIn,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema
                     .properties.languageIn
                     .path,
                 values: valueList.toArray(),
             }))
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))))
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema
                         .properties.languageIn
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((languageIn) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.maxCount,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema
                         .properties.maxCount
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.maxExclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema
                         .properties
                         .maxExclusive.path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.maxInclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -727,15 +742,15 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.maxLength,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -743,15 +758,15 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties.minCount,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -760,17 +775,17 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties
                 .minExclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -779,17 +794,17 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties
                 .minInclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -798,8 +813,8 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties
                 .minLength,
             typeFromRdf: (resourceValues) => resourceValues
@@ -807,7 +822,7 @@ export var PropertyShape;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -816,8 +831,8 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema.properties
                 .mutable,
             typeFromRdf: (resourceValues) => resourceValues
@@ -826,7 +841,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -835,19 +850,19 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((mutable) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .name,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.length >
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -856,17 +871,17 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((name) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .names,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -875,8 +890,8 @@ export var PropertyShape;
                 value: valuesArray,
             })),
         }).chain((names) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .nodeKind,
@@ -893,7 +908,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -902,8 +917,8 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((nodeKind) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .nodes,
@@ -911,7 +926,7 @@ export var PropertyShape;
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -920,8 +935,8 @@ export var PropertyShape;
                 value: valuesArray,
             })),
         }).chain((nodes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .not,
@@ -929,7 +944,7 @@ export var PropertyShape;
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -938,17 +953,17 @@ export var PropertyShape;
                 value: valuesArray,
             })),
         }).chain((not) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .or,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -959,7 +974,7 @@ export var PropertyShape;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -968,8 +983,8 @@ export var PropertyShape;
                 value: valuesArray,
             })),
         }).chain((or) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .order,
@@ -979,7 +994,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -988,31 +1003,36 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((order) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .path,
-            typeFromRdf: (resourceValues) => resourceValues.chain((values) => values.chainMap((value) => value
-                .toResource()
-                .chain((resource) => PropertyPath.$fromRdf(resource, {
-                context: $parameters.context,
+            typeFromRdf: (resourceValues) => $PropertyPath.$fromRdfResourceValues(resourceValues, {
+                context: _$options.context,
+                graph: _$options.graph,
+                preferredLanguages: _$options.preferredLanguages,
+                objectSet: _$options.objectSet,
+                resource: $resource,
                 ignoreRdfType: true,
-                objectSet: $parameters.objectSet,
-                preferredLanguages: $parameters.preferredLanguages,
-            })))),
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .path
+                    .path,
+            }),
         }).chain((path) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .patterns,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -1021,8 +1041,8 @@ export var PropertyShape;
                 value: valuesArray,
             })),
         }).chain((patterns) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .resolve,
@@ -1032,7 +1052,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -1041,8 +1061,8 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((resolve) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .uniqueLang,
@@ -1052,7 +1072,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -1061,8 +1081,8 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((uniqueLang) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .visibility,
@@ -1076,7 +1096,7 @@ export var PropertyShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -1085,17 +1105,17 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((visibility) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyShape.$schema
                 .properties
                 .xone,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -1106,7 +1126,7 @@ export var PropertyShape;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -1154,8 +1174,7 @@ export var PropertyShape;
             visibility,
             xone,
         }))))))))))))))))))))))))))))))))))))))));
-    }
-    PropertyShape.$propertiesFromRdf = $propertiesFromRdf;
+    };
     PropertyShape.$schema = {
         properties: {
             $identifier: {
@@ -1163,7 +1182,7 @@ export var PropertyShape;
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
                     ownValues: ["PropertyShape"],
@@ -1433,7 +1452,7 @@ export var PropertyShape;
             },
             path: {
                 kind: "Shacl",
-                type: () => PropertyPath.$schema,
+                type: () => $PropertyPath.$schema,
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
             },
             patterns: {
@@ -1488,7 +1507,7 @@ export var PropertyShape;
             },
         },
     };
-    function $toRdf(_propertyShape, options) {
+    function $toRdfResource(_propertyShape, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = resourceSet.resource(_propertyShape.$identifier);
@@ -1642,7 +1661,7 @@ export var PropertyShape;
             $literalFactory.number(value, $RdfVocabularies.xsd.double),
         ]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), [
-            PropertyPath.$toRdf(_propertyShape.path, {
+            $PropertyPath.$toRdfResource(_propertyShape.path, {
                 graph: options?.graph,
                 resourceSet: resourceSet,
             }).identifier,
@@ -1679,7 +1698,7 @@ export var PropertyShape;
         ]), options?.graph);
         return resource;
     }
-    PropertyShape.$toRdf = $toRdf;
+    PropertyShape.$toRdfResource = $toRdfResource;
 })(PropertyShape || (PropertyShape = {}));
 export var PropertyGroup;
 (function (PropertyGroup) {
@@ -1704,20 +1723,22 @@ export var PropertyGroup;
         return true;
     }
     PropertyGroup.$filter = $filter;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    PropertyGroup.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return PropertyGroup.$propertiesFromRdf({
+        return PropertyGroup.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
-    }
-    PropertyGroup.$fromRdf = $fromRdf;
+    };
+    PropertyGroup.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyGroup.$fromRdfResource(resource, options))));
     PropertyGroup.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
     function isPropertyGroup(object) {
         switch (object.$type) {
@@ -1728,10 +1749,10 @@ export var PropertyGroup;
         }
     }
     PropertyGroup.isPropertyGroup = isPropertyGroup;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
+    PropertyGroup.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
@@ -1740,50 +1761,49 @@ export var PropertyGroup;
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(PropertyGroup.$fromRdfType, {
-                    graph: $parameters.graph,
+                if ($resource.isInstanceOf(PropertyGroup.$fromRdfType, {
+                    graph: _$options.graph,
                 })) {
                     return Right(true);
                 }
-                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`));
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`));
             })
             : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
             dataFactory: dataFactory,
-            focusResource: $parameters.resource,
+            focusResource: $resource,
             propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
+            term: $resource.identifier,
         }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
             .chain((values) => values.head())
             .chain(($identifier) => Right("PropertyGroup").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyGroup.$schema.properties.comments,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyGroup.$schema.properties.comments.path,
                 value: valuesArray,
             })),
         }).chain((comments) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: PropertyGroup.$schema.properties.labels,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyGroup.$schema.properties.labels.path,
                 value: valuesArray,
             })),
         }).map((labels) => ({ $identifier, $type, comments, labels }))))));
-    }
-    PropertyGroup.$propertiesFromRdf = $propertiesFromRdf;
+    };
     PropertyGroup.$schema = {
         properties: {
             $identifier: {
@@ -1791,7 +1811,7 @@ export var PropertyGroup;
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
                     ownValues: ["PropertyGroup"],
@@ -1815,7 +1835,7 @@ export var PropertyGroup;
             },
         },
     };
-    function $toRdf(_propertyGroup, options) {
+    function $toRdfResource(_propertyGroup, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = resourceSet.resource(_propertyGroup.$identifier);
@@ -1826,7 +1846,7 @@ export var PropertyGroup;
         resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _propertyGroup.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         return resource;
     }
-    PropertyGroup.$toRdf = $toRdf;
+    PropertyGroup.$toRdfResource = $toRdfResource;
 })(PropertyGroup || (PropertyGroup = {}));
 export var Ontology;
 (function (Ontology) {
@@ -1863,20 +1883,22 @@ export var Ontology;
         return true;
     }
     Ontology.$filter = $filter;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    Ontology.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return Ontology.$propertiesFromRdf({
+        return Ontology.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
-    }
-    Ontology.$fromRdf = $fromRdf;
+    };
+    Ontology.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Ontology.$fromRdfResource(resource, options))));
     Ontology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
     function isOntology(object) {
         switch (object.$type) {
@@ -1887,10 +1909,10 @@ export var Ontology;
         }
     }
     Ontology.isOntology = isOntology;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
+    Ontology.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
@@ -1899,37 +1921,37 @@ export var Ontology;
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(Ontology.$fromRdfType, {
-                    graph: $parameters.graph,
+                if ($resource.isInstanceOf(Ontology.$fromRdfType, {
+                    graph: _$options.graph,
                 })) {
                     return Right(true);
                 }
-                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
             })
             : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
             dataFactory: dataFactory,
-            focusResource: $parameters.resource,
+            focusResource: $resource,
             propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
+            term: $resource.identifier,
         }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
             .chain((values) => values.head())
             .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: Ontology.$schema.properties.labels,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology.$schema.properties.labels.path,
                 value: valuesArray,
             })),
         }).chain((labels) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: Ontology.$schema.properties.tsFeatureExcludes,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri([
@@ -1946,13 +1968,13 @@ export var Ontology;
             ])))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology.$schema.properties.tsFeatureExcludes.path,
                 value: valuesArray,
             })),
         }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: Ontology.$schema.properties.tsFeatureIncludes,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri([
@@ -1969,26 +1991,26 @@ export var Ontology;
             ])))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology.$schema.properties.tsFeatureIncludes.path,
                 value: valuesArray,
             })),
         }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: Ontology.$schema.properties.tsImports,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology.$schema.properties.tsImports.path,
                 value: valuesArray,
             })),
         }).chain((tsImports) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: Ontology.$schema.properties.tsObjectDeclarationType,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri([
@@ -1998,7 +2020,7 @@ export var Ontology;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: Ontology.$schema.properties
                         .tsObjectDeclarationType.path,
                     value: Maybe.empty(),
@@ -2012,8 +2034,7 @@ export var Ontology;
             tsImports,
             tsObjectDeclarationType,
         })))))))));
-    }
-    Ontology.$propertiesFromRdf = $propertiesFromRdf;
+    };
     Ontology.$schema = {
         properties: {
             $identifier: {
@@ -2021,7 +2042,7 @@ export var Ontology;
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
                     ownValues: ["Ontology"],
@@ -2103,7 +2124,7 @@ export var Ontology;
             },
         },
     };
-    function $toRdf(_ontology, options) {
+    function $toRdfResource(_ontology, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = resourceSet.resource(_ontology.$identifier);
@@ -2117,7 +2138,7 @@ export var Ontology;
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), _ontology.tsObjectDeclarationType.toList(), options?.graph);
         return resource;
     }
-    Ontology.$toRdf = $toRdf;
+    Ontology.$toRdfResource = $toRdfResource;
 })(Ontology || (Ontology = {}));
 export var NodeShape;
 (function (NodeShape) {
@@ -2163,10 +2184,6 @@ export var NodeShape;
             !$filterMaybe($filterString)(filter.discriminantValue, value.discriminantValue)) {
             return false;
         }
-        if (filter.export_ !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.export_, value.export_)) {
-            return false;
-        }
         if (filter.extern !== undefined &&
             !$filterMaybe($filterBoolean)(filter.extern, value.extern)) {
             return false;
@@ -2302,20 +2319,22 @@ export var NodeShape;
         return true;
     }
     NodeShape.$filter = $filter;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    NodeShape.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return NodeShape.$propertiesFromRdf({
+        return NodeShape.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
-    }
-    NodeShape.$fromRdf = $fromRdf;
+    };
+    NodeShape.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => NodeShape.$fromRdfResource(resource, options))));
     NodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     function isNodeShape(object) {
         switch (object.$type) {
@@ -2326,10 +2345,10 @@ export var NodeShape;
         }
     }
     NodeShape.isNodeShape = isNodeShape;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
+    NodeShape.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
                 .chain((actualRdfType) => actualRdfType.toIri())
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
@@ -2338,192 +2357,178 @@ export var NodeShape;
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(NodeShape.$fromRdfType, {
-                    graph: $parameters.graph,
+                if ($resource.isInstanceOf(NodeShape.$fromRdfType, {
+                    graph: _$options.graph,
                 })) {
                     return Right(true);
                 }
-                return Left(new Error(`${Resource.Identifier.toString($parameters.resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`));
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`));
             })
             : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
             dataFactory: dataFactory,
-            focusResource: $parameters.resource,
+            focusResource: $resource,
             propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
+            term: $resource.identifier,
         }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
             .chain((values) => values.head())
             .chain(($identifier) => Right("NodeShape").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.abstract,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape.$schema.properties.abstract.path,
                     value: Maybe.empty(),
                 })),
         }).chain((abstract) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.and,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
+                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.and.path,
                 values: valueList.toArray(),
             })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.and.path,
                 value: valuesArray,
             })),
         }).chain((and) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.classes,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.classes.path,
                 value: valuesArray,
             })),
         }).chain((classes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.closed,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape.$schema.properties.closed.path,
                     value: Maybe.empty(),
                 })),
         }).chain((closed) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.comments,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties.comments.path,
                 value: valuesArray,
             })),
         }).chain((comments) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.datatype,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties.datatype
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((datatype) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.deactivated,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema.properties
                         .deactivated.path,
                     value: Maybe.empty(),
                 })),
         }).chain((deactivated) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.discriminantValue,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape.$schema.properties
                         .discriminantValue.path,
                     value: Maybe.empty(),
                 })),
         }).chain((discriminantValue) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: NodeShape.$schema.properties.export_,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: NodeShape.$schema.properties.export_
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((export_) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.extern,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: NodeShape.$schema.properties
-                        .extern.path,
+                    focusResource: $resource,
+                    propertyPath: NodeShape.$schema.properties.extern
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((extern) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.flags,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: PropertyShape.$schema.properties
-                    .flags.path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.flags
+                    .path,
                 value: valuesArray,
             })),
         }).chain((flags) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.fromRdfType,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape.$schema.properties
                         .fromRdfType.path,
                     value: Maybe.empty(),
                 })),
         }).chain((fromRdfType) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.hasValues,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
@@ -2535,9 +2540,8 @@ export var NodeShape;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
-                            propertyPath: PropertyShape
-                                .$schema
+                            focusResource: $resource,
+                            propertyPath: PropertyShape.$schema
                                 .properties
                                 .hasValues.path,
                         }));
@@ -2545,14 +2549,14 @@ export var NodeShape;
             })))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape.$schema.properties
                     .hasValues.path,
                 value: valuesArray,
             })),
         }).chain((hasValues) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties
                 .identifierMintingStrategy,
             typeFromRdf: (resourceValues) => resourceValues
@@ -2564,51 +2568,47 @@ export var NodeShape;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: NodeShape.$schema
-                        .properties
+                    focusResource: $resource,
+                    propertyPath: NodeShape.$schema.properties
                         .identifierMintingStrategy
                         .path,
                     value: Maybe.empty(),
                 })),
         }).chain((identifierMintingStrategy) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: NodeShape.$schema.properties
-                .ignoredProperties,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.ignoredProperties,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: NodeShape.$schema
                     .properties
-                    .ignoredProperties
-                    .path,
+                    .ignoredProperties.path,
                 values: valueList.toArray(),
             })).chain((values) => values.chainMap((value) => value.toIri()))))
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape.$schema
                         .properties
-                        .ignoredProperties
-                        .path,
+                        .ignoredProperties.path,
                     value: Maybe.empty(),
                 })),
         }).chain((ignoredProperties) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.in_,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties.in_
@@ -2625,7 +2625,7 @@ export var NodeShape;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
+                            focusResource: $resource,
                             propertyPath: PropertyShape
                                 .$schema
                                 .properties
@@ -2638,55 +2638,51 @@ export var NodeShape;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape.$schema
-                        .properties.in_
-                        .path,
+                        .properties.in_.path,
                     value: Maybe.empty(),
                 })),
         }).chain((in_) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.isDefinedBy,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: PropertyShape
-                        .$schema
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
                         .properties
                         .isDefinedBy.path,
                     value: Maybe.empty(),
                 })),
         }).chain((isDefinedBy) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties.labels,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: PropertyShape
-                    .$schema
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema
                     .properties.labels
                     .path,
                 value: valuesArray,
             })),
         }).chain((labels) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: NodeShape.$schema.properties
-                .languageIn,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.languageIn,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -2694,13 +2690,13 @@ export var NodeShape;
                     .path,
                 values: valueList.toArray(),
             }))
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))))
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2709,16 +2705,15 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((languageIn) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: NodeShape.$schema.properties
-                .maxCount,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.maxCount,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2727,17 +2722,17 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties
                 .maxExclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2746,17 +2741,17 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties
                 .maxInclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2765,17 +2760,16 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema.properties
                 .maxLength,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
-                .map((values) => values.length >
-                0
+                .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2784,10 +2778,9 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((maxLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: NodeShape.$schema
-                .properties
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
                 .minCount,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
@@ -2795,7 +2788,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2804,19 +2797,19 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .minExclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length >
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2825,19 +2818,19 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .minInclusive,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
                 .map((values) => values.length >
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2846,8 +2839,8 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .minLength,
@@ -2857,7 +2850,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2866,8 +2859,8 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((minLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .mutable,
@@ -2877,7 +2870,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2886,19 +2879,19 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((mutable) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .name,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.length >
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2907,8 +2900,8 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((name) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .nodeKind,
@@ -2925,7 +2918,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: PropertyShape
                         .$schema
                         .properties
@@ -2934,8 +2927,8 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((nodeKind) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .nodes,
@@ -2943,7 +2936,7 @@ export var NodeShape;
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -2952,8 +2945,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((nodes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .not,
@@ -2961,7 +2954,7 @@ export var NodeShape;
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -2970,17 +2963,17 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((not) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .or,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -2991,7 +2984,7 @@ export var NodeShape;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -3000,17 +2993,17 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((or) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .patterns,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -3019,8 +3012,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((patterns) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .properties,
@@ -3028,7 +3021,7 @@ export var NodeShape;
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: NodeShape
                     .$schema
                     .properties
@@ -3037,8 +3030,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((properties) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .rdfType,
@@ -3048,7 +3041,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: NodeShape
                         .$schema
                         .properties
@@ -3057,8 +3050,8 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((rdfType) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .toRdfTypes,
@@ -3066,7 +3059,7 @@ export var NodeShape;
                 .chain((values) => values.chainMap((value) => value.toIri()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: NodeShape
                     .$schema
                     .properties
@@ -3075,8 +3068,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((toRdfTypes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .tsFeatureExcludes,
@@ -3095,7 +3088,7 @@ export var NodeShape;
             ])))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology
                     .$schema
                     .properties
@@ -3104,8 +3097,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .tsFeatureIncludes,
@@ -3124,7 +3117,7 @@ export var NodeShape;
             ])))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology
                     .$schema
                     .properties
@@ -3133,17 +3126,17 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .tsImports,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: Ontology
                     .$schema
                     .properties
@@ -3152,8 +3145,8 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((tsImports) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .tsObjectDeclarationType,
@@ -3166,7 +3159,7 @@ export var NodeShape;
                 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
+                    focusResource: $resource,
                     propertyPath: Ontology
                         .$schema
                         .properties
@@ -3175,17 +3168,17 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((tsObjectDeclarationType) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
+            graph: _$options.graph,
+            resource: $resource,
             propertySchema: NodeShape.$schema
                 .properties
                 .xone,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toList({
-                graph: $parameters.graph,
+                graph: _$options.graph,
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -3196,7 +3189,7 @@ export var NodeShape;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
+                focusResource: $resource,
                 propertyPath: PropertyShape
                     .$schema
                     .properties
@@ -3215,7 +3208,6 @@ export var NodeShape;
             datatype,
             deactivated,
             discriminantValue,
-            export_,
             extern,
             flags,
             fromRdfType,
@@ -3249,9 +3241,8 @@ export var NodeShape;
             tsImports,
             tsObjectDeclarationType,
             xone,
-        }))))))))))))))))))))))))))))))))))))))))))))));
-    }
-    NodeShape.$propertiesFromRdf = $propertiesFromRdf;
+        })))))))))))))))))))))))))))))))))))))))))))));
+    };
     NodeShape.$schema = {
         properties: {
             $identifier: {
@@ -3259,7 +3250,7 @@ export var NodeShape;
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
                     ownValues: ["NodeShape"],
@@ -3332,14 +3323,6 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"),
             },
-            export_: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#export"),
-            },
             extern: {
                 kind: "Shacl",
                 type: () => ({
@@ -3672,7 +3655,7 @@ export var NodeShape;
             },
         },
     };
-    function $toRdf(_nodeShape, options) {
+    function $toRdfResource(_nodeShape, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
         const resource = resourceSet.resource(_nodeShape.$identifier);
@@ -3722,11 +3705,6 @@ export var NodeShape;
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"), _nodeShape.discriminantValue
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#export"), _nodeShape.export_
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"), _nodeShape.extern
             .toList()
             .flatMap((value) => [
@@ -3893,48 +3871,81 @@ export var NodeShape;
         ]), options?.graph);
         return resource;
     }
-    NodeShape.$toRdf = $toRdf;
+    NodeShape.$toRdfResource = $toRdfResource;
 })(NodeShape || (NodeShape = {}));
 export var Shape;
 (function (Shape) {
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = Shape.$Identifier || (Shape.$Identifier = {}));
-    function $filter(filter, value) {
+    Shape.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
+        }
+        throw new Error("unrecognized type");
+    };
+    Shape.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (NodeShape.isNodeShape(value) &&
-            filter.on?.NodeShape &&
-            !NodeShape.$filter(filter.on.NodeShape, value)) {
-            return false;
+        if (filter.on?.["NodeShape"] !== undefined &&
+            NodeShape.isNodeShape(value)) {
+            if (!NodeShape.$filter(filter.on["NodeShape"], value)) {
+                return false;
+            }
         }
-        if (PropertyShape.isPropertyShape(value) &&
-            filter.on?.PropertyShape &&
-            !PropertyShape.$filter(filter.on.PropertyShape, value)) {
-            return false;
+        if (filter.on?.["PropertyShape"] !== undefined &&
+            PropertyShape.isPropertyShape(value)) {
+            if (!PropertyShape.$filter(filter.on["PropertyShape"], value)) {
+                return false;
+            }
         }
         return true;
-    }
-    Shape.$filter = $filter;
-    function $fromRdf(resource, options) {
-        return NodeShape.$fromRdf(resource, {
-            ...options,
+    };
+    Shape.$fromRdfResource = (resource, options) => NodeShape.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }).altLazy(() => PropertyShape.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }));
+    Shape.$fromRdfResourceValues = ((values, _options) => values.chain((values) => values.chainMap((value) => {
+        const valueAsValues = Right(value.toValues());
+        return NodeShape.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
-        }).altLazy(() => PropertyShape.$fromRdf(resource, {
-            ...options,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
+        })
+            .altLazy(() => PropertyShape.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
-        }));
-    }
-    Shape.$fromRdf = $fromRdf;
-    function isShape(object) {
-        return (NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object));
-    }
-    Shape.isShape = isShape;
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
+        }))
+            .chain((values) => values.head());
+    })));
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = Shape.$Identifier || (Shape.$Identifier = {}));
     Shape.$schema = {
+        kind: "NamedObjectUnion",
+        members: {
+            NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.$schema },
+            PropertyShape: {
+                discriminantValues: ["PropertyShape"],
+                type: PropertyShape.$schema,
+            },
+        },
         properties: {
             and: {
                 kind: "Shacl",
@@ -4179,72 +4190,152 @@ export var Shape;
             },
         },
     };
-    function $toRdf(_shape, _parameters) {
-        if (NodeShape.isNodeShape(_shape)) {
-            return NodeShape.$toRdf(_shape, _parameters);
-        }
-        if (PropertyShape.isPropertyShape(_shape)) {
-            return PropertyShape.$toRdf(_shape, _parameters);
-        }
-        throw new Error("unrecognized type");
+    Shape.$toRdfResourceValues = ((value, _options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return [
+                NodeShape.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return [
+                PropertyShape.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        throw new Error("unable to serialize to RDF");
+    });
+    function isShape(object) {
+        return (NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object));
     }
-    Shape.$toRdf = $toRdf;
+    Shape.isShape = isShape;
 })(Shape || (Shape = {}));
 export var $Object;
 (function ($Object) {
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = $Object.$Identifier || ($Object.$Identifier = {}));
-    function $filter(filter, value) {
+    $Object.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
+        }
+        if (Ontology.isOntology(value)) {
+            return Ontology.$toRdfResource(value, options);
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return PropertyGroup.$toRdfResource(value, options);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
+        }
+        throw new Error("unrecognized type");
+    };
+    $Object.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (NodeShape.isNodeShape(value) &&
-            filter.on?.NodeShape &&
-            !NodeShape.$filter(filter.on.NodeShape, value)) {
-            return false;
+        if (filter.on?.["NodeShape"] !== undefined &&
+            NodeShape.isNodeShape(value)) {
+            if (!NodeShape.$filter(filter.on["NodeShape"], value)) {
+                return false;
+            }
         }
-        if (Ontology.isOntology(value) &&
-            filter.on?.Ontology &&
-            !Ontology.$filter(filter.on.Ontology, value)) {
-            return false;
+        if (filter.on?.["Ontology"] !== undefined && Ontology.isOntology(value)) {
+            if (!Ontology.$filter(filter.on["Ontology"], value)) {
+                return false;
+            }
         }
-        if (PropertyGroup.isPropertyGroup(value) &&
-            filter.on?.PropertyGroup &&
-            !PropertyGroup.$filter(filter.on.PropertyGroup, value)) {
-            return false;
+        if (filter.on?.["PropertyGroup"] !== undefined &&
+            PropertyGroup.isPropertyGroup(value)) {
+            if (!PropertyGroup.$filter(filter.on["PropertyGroup"], value)) {
+                return false;
+            }
         }
-        if (PropertyShape.isPropertyShape(value) &&
-            filter.on?.PropertyShape &&
-            !PropertyShape.$filter(filter.on.PropertyShape, value)) {
-            return false;
+        if (filter.on?.["PropertyShape"] !== undefined &&
+            PropertyShape.isPropertyShape(value)) {
+            if (!PropertyShape.$filter(filter.on["PropertyShape"], value)) {
+                return false;
+            }
         }
         return true;
-    }
-    $Object.$filter = $filter;
-    function $fromRdf(resource, options) {
-        return NodeShape.$fromRdf(resource, {
-            ...options,
+    };
+    $Object.$fromRdfResource = (resource, options) => NodeShape.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    })
+        .altLazy(() => Ontology.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => PropertyGroup.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => PropertyShape.$fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }));
+    $Object.$fromRdfResourceValues = ((values, _options) => values.chain((values) => values.chainMap((value) => {
+        const valueAsValues = Right(value.toValues());
+        return NodeShape.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
         })
-            .altLazy(() => Ontology.$fromRdf(resource, {
-            ...options,
+            .altLazy(() => Ontology.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
         }))
-            .altLazy(() => PropertyGroup.$fromRdf(resource, {
-            ...options,
+            .altLazy(() => PropertyGroup.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
         }))
-            .altLazy(() => PropertyShape.$fromRdf(resource, {
-            ...options,
+            .altLazy(() => PropertyShape.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
             ignoreRdfType: false,
-        }));
-    }
-    $Object.$fromRdf = $fromRdf;
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
+        }))
+            .chain((values) => values.head());
+    })));
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = $Object.$Identifier || ($Object.$Identifier = {}));
     $Object.$schema = {
+        kind: "NamedObjectUnion",
+        members: {
+            NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.$schema },
+            Ontology: { discriminantValues: ["Ontology"], type: Ontology.$schema },
+            PropertyGroup: {
+                discriminantValues: ["PropertyGroup"],
+                type: PropertyGroup.$schema,
+            },
+            PropertyShape: {
+                discriminantValues: ["PropertyShape"],
+                type: PropertyShape.$schema,
+            },
+        },
         properties: {
             labels: {
                 kind: "Shacl",
@@ -4256,22 +4347,41 @@ export var $Object;
             },
         },
     };
-    function $toRdf(_object, _parameters) {
-        if (NodeShape.isNodeShape(_object)) {
-            return NodeShape.$toRdf(_object, _parameters);
-        }
-        if (Ontology.isOntology(_object)) {
-            return Ontology.$toRdf(_object, _parameters);
-        }
-        if (PropertyGroup.isPropertyGroup(_object)) {
-            return PropertyGroup.$toRdf(_object, _parameters);
-        }
-        if (PropertyShape.isPropertyShape(_object)) {
-            return PropertyShape.$toRdf(_object, _parameters);
-        }
-        throw new Error("unrecognized type");
-    }
-    $Object.$toRdf = $toRdf;
+    $Object.$toRdfResourceValues = ((value, _options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return [
+                NodeShape.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (Ontology.isOntology(value)) {
+            return [
+                Ontology.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return [
+                PropertyGroup.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return [
+                PropertyShape.$toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        throw new Error("unable to serialize to RDF");
+    });
 })($Object || ($Object = {}));
 export class $RdfjsDatasetObjectSet {
     $graph;
@@ -4316,7 +4426,7 @@ export class $RdfjsDatasetObjectSet {
     nodeShapesSync(query) {
         return this.$objectsSync({
             $filter: NodeShape.$filter,
-            $fromRdf: NodeShape.$fromRdf,
+            $fromRdfResource: NodeShape.$fromRdfResource,
             $fromRdfTypes: [NodeShape.$fromRdfType],
         }, query);
     }
@@ -4347,7 +4457,7 @@ export class $RdfjsDatasetObjectSet {
     ontologiesSync(query) {
         return this.$objectsSync({
             $filter: Ontology.$filter,
-            $fromRdf: Ontology.$fromRdf,
+            $fromRdfResource: Ontology.$fromRdfResource,
             $fromRdfTypes: [Ontology.$fromRdfType],
         }, query);
     }
@@ -4378,7 +4488,7 @@ export class $RdfjsDatasetObjectSet {
     propertyGroupsSync(query) {
         return this.$objectsSync({
             $filter: PropertyGroup.$filter,
-            $fromRdf: PropertyGroup.$fromRdf,
+            $fromRdfResource: PropertyGroup.$fromRdfResource,
             $fromRdfTypes: [PropertyGroup.$fromRdfType],
         }, query);
     }
@@ -4409,7 +4519,7 @@ export class $RdfjsDatasetObjectSet {
     propertyShapesSync(query) {
         return this.$objectsSync({
             $filter: PropertyShape.$filter,
-            $fromRdf: PropertyShape.$fromRdf,
+            $fromRdfResource: PropertyShape.$fromRdfResource,
             $fromRdfTypes: [PropertyShape.$fromRdfType],
         }, query);
     }
@@ -4441,12 +4551,12 @@ export class $RdfjsDatasetObjectSet {
         return this.$objectUnionsSync([
             {
                 $filter: Shape.$filter,
-                $fromRdf: NodeShape.$fromRdf,
+                $fromRdfResource: NodeShape.$fromRdfResource,
                 $fromRdfTypes: [NodeShape.$fromRdfType],
             },
             {
                 $filter: Shape.$filter,
-                $fromRdf: PropertyShape.$fromRdf,
+                $fromRdfResource: PropertyShape.$fromRdfResource,
                 $fromRdfTypes: [PropertyShape.$fromRdfType],
             },
         ], query);
@@ -4479,22 +4589,22 @@ export class $RdfjsDatasetObjectSet {
         return this.$objectUnionsSync([
             {
                 $filter: $Object.$filter,
-                $fromRdf: NodeShape.$fromRdf,
+                $fromRdfResource: NodeShape.$fromRdfResource,
                 $fromRdfTypes: [NodeShape.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: Ontology.$fromRdf,
+                $fromRdfResource: Ontology.$fromRdfResource,
                 $fromRdfTypes: [Ontology.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: PropertyGroup.$fromRdf,
+                $fromRdfResource: PropertyGroup.$fromRdfResource,
                 $fromRdfTypes: [PropertyGroup.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: PropertyShape.$fromRdf,
+                $fromRdfResource: PropertyShape.$fromRdfResource,
                 $fromRdfTypes: [PropertyShape.$fromRdfType],
             },
         ], query);
@@ -4509,7 +4619,7 @@ export class $RdfjsDatasetObjectSet {
         if (offset < 0) {
             offset = 0;
         }
-        const fromRdfOptions = {
+        const fromRdfResourceOptions = {
             graph,
             objectSet: this,
             preferredLanguages: query?.preferredLanguages,
@@ -4559,7 +4669,9 @@ export class $RdfjsDatasetObjectSet {
                 identifierSet.add(quad.subject);
                 const resource = resourceSet.resource(quad.subject);
                 // Eagerly eliminate the majority of resources that won't match the object type
-                objectType.$fromRdf(resource, fromRdfOptions).ifRight((object) => {
+                objectType
+                    .$fromRdfResource(resource, fromRdfResourceOptions)
+                    .ifRight((object) => {
                     resources.push({ object, resource });
                 });
             }
@@ -4572,7 +4684,7 @@ export class $RdfjsDatasetObjectSet {
         const objects = [];
         for (let { object, resource } of resources) {
             if (!object) {
-                const objectEither = objectType.$fromRdf(resource, fromRdfOptions);
+                const objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 if (objectEither.isLeft()) {
                     return objectEither;
                 }
@@ -4600,7 +4712,7 @@ export class $RdfjsDatasetObjectSet {
         if (offset < 0) {
             offset = 0;
         }
-        const fromRdfOptions = {
+        const fromRdfResourceOptions = {
             graph,
             objectSet: this,
             preferredLanguages: query?.preferredLanguages,
@@ -4654,7 +4766,7 @@ export class $RdfjsDatasetObjectSet {
                 const resource = resourceSet.resource(quad.subject);
                 for (const objectType of objectTypes) {
                     if (objectType
-                        .$fromRdf(resource, fromRdfOptions)
+                        .$fromRdfResource(resource, fromRdfResourceOptions)
                         .ifRight((object) => {
                         resources.push({ object, objectType, resource });
                     })
@@ -4674,12 +4786,12 @@ export class $RdfjsDatasetObjectSet {
             if (!object) {
                 let objectEither;
                 if (objectType) {
-                    objectEither = objectType.$fromRdf(resource, fromRdfOptions);
+                    objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 }
                 else {
                     objectEither = Left(new Error("no object types"));
                     for (const tryObjectType of objectTypes) {
-                        objectEither = tryObjectType.$fromRdf(resource, fromRdfOptions);
+                        objectEither = tryObjectType.$fromRdfResource(resource, fromRdfResourceOptions);
                         if (objectEither.isRight()) {
                             objectType = tryObjectType;
                             break;