@shaclmate/shacl-ast 4.0.7 → 4.0.9

package/dist/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;
@@ -204,8 +217,13 @@ var $RdfVocabularies;
 function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }) {
     return typeFromRdf(Right(resource.values(propertySchema.path, { graph, unique: true }))).chain((values) => values.head());
 }
-export var BaseShaclCoreShapeStatic;
-(function (BaseShaclCoreShapeStatic) {
+export var PropertyShape;
+(function (PropertyShape) {
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = PropertyShape.$Identifier || (PropertyShape.$Identifier = {}));
     function $filter(filter, value) {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
@@ -231,10 +249,22 @@ export var BaseShaclCoreShapeStatic;
             !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
             return false;
         }
+        if (filter.defaultValue !== undefined &&
+            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
+            return false;
+        }
+        if (filter.descriptions !== undefined &&
+            !$filterArray($filterString)(filter.descriptions, value.descriptions)) {
+            return false;
+        }
         if (filter.flags !== undefined &&
             !$filterArray($filterString)(filter.flags, value.flags)) {
             return false;
         }
+        if (filter.groups !== undefined &&
+            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
+            return false;
+        }
         if (filter.hasValues !== undefined &&
             !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
             return false;
@@ -287,6 +317,10 @@ export var BaseShaclCoreShapeStatic;
             !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
             return false;
         }
+        if (filter.names !== undefined &&
+            !$filterArray($filterString)(filter.names, value.names)) {
+            return false;
+        }
         if (filter.nodeKind !== undefined &&
             !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
             return false;
@@ -303,131 +337,226 @@ export var BaseShaclCoreShapeStatic;
             !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
             return false;
         }
+        if (filter.order !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
+            return false;
+        }
+        if (filter.path !== undefined &&
+            !$PropertyPath.$filter(filter.path, value.path)) {
+            return false;
+        }
         if (filter.patterns !== undefined &&
             !$filterArray($filterString)(filter.patterns, value.patterns)) {
             return false;
         }
+        if (filter.uniqueLang !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
+            return false;
+        }
         if (filter.xone !== undefined &&
             !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
             return false;
         }
         return true;
     }
-    BaseShaclCoreShapeStatic.$filter = $filter;
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
-    function isBaseShaclCoreShape(object) {
+    PropertyShape.$filter = $filter;
+    PropertyShape.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        }
+        return PropertyShape.$propertiesFromRdfResource(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            objectSet,
+            preferredLanguages,
+        });
+    };
+    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) {
-            case "ShaclCoreNodeShape":
-            case "ShaclCorePropertyShape":
+            case "PropertyShape":
                 return true;
             default:
                 return false;
         }
     }
-    BaseShaclCoreShapeStatic.isBaseShaclCoreShape = isBaseShaclCoreShape;
-    function $propertiesFromRdf($parameters) {
-        return Right(new Resource.Value({
+    PropertyShape.isPropertyShape = isPropertyShape;
+    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
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/ns/shacl#PropertyShape":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(PropertyShape.$fromRdfType, {
+                    graph: _$options.graph,
+                })) {
+                    return Right(true);
+                }
+                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) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.and,
+            .chain(($identifier) => Right("PropertyShape").chain(($type) => $shaclPropertyFromRdf({
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.and.path,
+                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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.and.path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.and.path,
                 value: valuesArray,
             })),
         }).chain((and) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.classes,
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.classes.path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.classes.path,
                 value: valuesArray,
             })),
         }).chain((classes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.comments,
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.comments
-                    .path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.comments.path,
                 value: valuesArray,
             })),
         }).chain((comments) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.datatype,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema.properties
-                        .datatype.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.datatype
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((datatype) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.deactivated,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema.properties
-                        .deactivated.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.deactivated
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((deactivated) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.flags,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.defaultValue,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $resource,
+                            propertyPath: PropertyShape.$schema.properties
+                                .defaultValue.path,
+                        }));
+                }
+            })))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .defaultValue.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((defaultValue) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.descriptions,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
+                    .descriptions.path,
+                value: valuesArray,
+            })),
+        }).chain((descriptions) => $shaclPropertyFromRdf({
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties.flags
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.flags
                     .path,
                 value: valuesArray,
             })),
         }).chain((flags) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.hasValues,
+            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: $resource,
+                propertyPath: PropertyShape.$schema.properties.groups
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((groups) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.hasValues,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
                 switch (term.termType) {
@@ -438,29 +567,32 @@ export var BaseShaclCoreShapeStatic;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
-                            propertyPath: BaseShaclCoreShapeStatic.$schema
-                                .properties.hasValues.path,
+                            focusResource: $resource,
+                            propertyPath: PropertyShape.$schema
+                                .properties.hasValues
+                                .path,
                         }));
                 }
             })))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: BaseShaclCoreShapeStatic.$schema.properties
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
                     .hasValues.path,
                 value: valuesArray,
             })),
         }).chain((hasValues) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.in_,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.in_,
             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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema
-                    .properties.in_.path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
+                    .in_.path,
                 values: valueList.toArray(),
             })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
                 switch (term.termType) {
@@ -471,9 +603,10 @@ export var BaseShaclCoreShapeStatic;
                         return Left(new Resource.MistypedTermValueError({
                             actualValue: term,
                             expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
-                            propertyPath: BaseShaclCoreShapeStatic
-                                .$schema.properties.in_
+                            focusResource: $resource,
+                            propertyPath: PropertyShape
+                                .$schema
+                                .properties.in_
                                 .path,
                         }));
                 }
@@ -482,191 +615,229 @@ export var BaseShaclCoreShapeStatic;
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema
-                        .properties.in_.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .in_.path,
                     value: Maybe.empty(),
                 })),
         }).chain((in_) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.isDefinedBy,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema
-                        .properties.isDefinedBy.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.isDefinedBy
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((isDefinedBy) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.labels,
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema
-                    .properties.labels.path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
+                    .labels.path,
                 value: valuesArray,
             })),
         }).chain((labels) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.languageIn,
+            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,
-                propertyPath: BaseShaclCoreShapeStatic.$schema
-                    .properties.languageIn.path,
+                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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema
-                        .properties.languageIn.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.languageIn
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((languageIn) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxCount,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema
-                        .properties.maxCount.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.maxCount
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxExclusive,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic.$schema
-                        .properties.maxExclusive.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties
+                        .maxExclusive.path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxInclusive,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic
-                        .$schema.properties
-                        .maxInclusive.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .maxInclusive
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.maxLength,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic
-                        .$schema.properties
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
                         .maxLength.path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minCount,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic
-                        .$schema.properties
-                        .minCount.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minCount
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((minCount) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minExclusive,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic
-                        .$schema.properties
-                        .minExclusive.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minExclusive
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((minExclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minInclusive,
+            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,
-                    propertyPath: BaseShaclCoreShapeStatic
-                        .$schema.properties
-                        .minInclusive.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minInclusive
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((minInclusive) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.minLength,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties
+                .minLength,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: BaseShaclCoreShapeStatic
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
                         .$schema
                         .properties
-                        .minLength.path,
+                        .minLength
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((minLength) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.nodeKind,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties
+                .names,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .names
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((names) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .nodeKind,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIri([
                 dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
@@ -676,57 +847,67 @@ export var BaseShaclCoreShapeStatic;
                 dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
                 dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
             ])))
-                .map((values) => values.length > 0
+                .map((values) => values.length >
+                0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: BaseShaclCoreShapeStatic
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
                         .$schema
                         .properties
-                        .nodeKind.path,
+                        .nodeKind
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((nodeKind) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.nodes,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .nodes,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
-                    .nodes.path,
+                    .nodes
+                    .path,
                 value: valuesArray,
             })),
         }).chain((nodes) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.not,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .not,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toIdentifier()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
-                    .not.path,
+                    .not
+                    .path,
                 value: valuesArray,
             })),
         }).chain((not) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties.or,
+            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,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
                     .or
@@ -736,25 +917,66 @@ export var BaseShaclCoreShapeStatic;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
-                    .or.path,
+                    .or
+                    .path,
                 value: valuesArray,
             })),
         }).chain((or) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .order,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toFloat()))
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .order
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((order) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .path,
+            typeFromRdf: (resourceValues) => $PropertyPath.$fromRdfResourceValues(resourceValues, {
+                context: _$options.context,
+                graph: _$options.graph,
+                preferredLanguages: _$options.preferredLanguages,
+                objectSet: _$options.objectSet,
+                resource: $resource,
+                ignoreRdfType: true,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .path
+                    .path,
+            }),
+        }).chain((path) => $shaclPropertyFromRdf({
+            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,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
                     .patterns
@@ -762,17 +984,38 @@ export var BaseShaclCoreShapeStatic;
                 value: valuesArray,
             })),
         }).chain((patterns) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: BaseShaclCoreShapeStatic.$schema.properties
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .uniqueLang,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .uniqueLang
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((uniqueLang) => $shaclPropertyFromRdf({
+            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,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
                     .xone
@@ -782,8 +1025,8 @@ export var BaseShaclCoreShapeStatic;
                 .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: BaseShaclCoreShapeStatic
+                focusResource: $resource,
+                propertyPath: PropertyShape
                     .$schema
                     .properties
                     .xone
@@ -792,12 +1035,16 @@ export var BaseShaclCoreShapeStatic;
             })),
         }).map((xone) => ({
             $identifier,
+            $type,
             and,
             classes,
             comments,
             datatype,
             deactivated,
+            defaultValue,
+            descriptions,
             flags,
+            groups,
             hasValues,
             in_,
             isDefinedBy,
@@ -811,191 +1058,29 @@ export var BaseShaclCoreShapeStatic;
             minExclusive,
             minInclusive,
             minLength,
+            names,
             nodeKind,
             nodes,
             not,
             or,
+            order,
+            path,
             patterns,
+            uniqueLang,
             xone,
-        })))))))))))))))))))))))))));
-    }
-    BaseShaclCoreShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
-    function $toRdf(_baseShaclCoreShape, options) {
-        const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = resourceSet.resource(_baseShaclCoreShape.$identifier);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _baseShaclCoreShape.and.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: resourceSet.resource(dataFactory.blankNode()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), _baseShaclCoreShape.classes.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _baseShaclCoreShape.comments.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), _baseShaclCoreShape.datatype.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), _baseShaclCoreShape.deactivated
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), _baseShaclCoreShape.flags.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), _baseShaclCoreShape.hasValues.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), _baseShaclCoreShape.in_.toList().flatMap((value) => [
-            value.length > 0
-                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: resourceSet.resource(dataFactory.blankNode()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), _baseShaclCoreShape.isDefinedBy.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _baseShaclCoreShape.labels.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), _baseShaclCoreShape.languageIn.toList().flatMap((value) => [
-            value.length > 0
-                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], options?.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: resourceSet.resource(dataFactory.blankNode()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), _baseShaclCoreShape.maxCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), _baseShaclCoreShape.maxExclusive.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), _baseShaclCoreShape.maxInclusive.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), _baseShaclCoreShape.maxLength
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), _baseShaclCoreShape.minCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), _baseShaclCoreShape.minExclusive.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), _baseShaclCoreShape.minInclusive.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), _baseShaclCoreShape.minLength
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _baseShaclCoreShape.nodeKind.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _baseShaclCoreShape.nodes.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _baseShaclCoreShape.not.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _baseShaclCoreShape.or.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: resourceSet.resource(dataFactory.blankNode()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _baseShaclCoreShape.patterns.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _baseShaclCoreShape.xone.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: resourceSet.resource(dataFactory.blankNode()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), options?.graph);
-        return resource;
-    }
-    BaseShaclCoreShapeStatic.$toRdf = $toRdf;
-    BaseShaclCoreShapeStatic.$schema = {
+        }))))))))))))))))))))))))))))))))))));
+    };
+    PropertyShape.$schema = {
         properties: {
             $identifier: {
                 kind: "Identifier",
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
-                    descendantValues: ["ShaclCoreNodeShape", "ShaclCorePropertyShape"],
                     kind: "TypeDiscriminant",
+                    ownValues: ["PropertyShape"],
                 }),
             },
             and: {
@@ -1041,6 +1126,22 @@ export var BaseShaclCoreShapeStatic;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
             },
+            defaultValue: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Term" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
+            },
+            descriptions: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+            },
             flags: {
                 kind: "Shacl",
                 type: () => ({
@@ -1049,6 +1150,14 @@ export var BaseShaclCoreShapeStatic;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
             },
+            groups: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+            },
             hasValues: {
                 kind: "Shacl",
                 type: () => ({
@@ -1159,6 +1268,14 @@ export var BaseShaclCoreShapeStatic;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
             },
+            names: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -1204,6 +1321,19 @@ export var BaseShaclCoreShapeStatic;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
             },
+            order: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Float" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+            },
+            path: {
+                kind: "Shacl",
+                type: () => $PropertyPath.$schema,
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+            },
             patterns: {
                 kind: "Shacl",
                 type: () => ({
@@ -1212,6 +1342,14 @@ export var BaseShaclCoreShapeStatic;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
             },
+            uniqueLang: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+            },
             xone: {
                 kind: "Shacl",
                 type: () => ({
@@ -1225,321 +1363,196 @@ export var BaseShaclCoreShapeStatic;
             },
         },
     };
-})(BaseShaclCoreShapeStatic || (BaseShaclCoreShapeStatic = {}));
-export var ShaclCorePropertyShape;
-(function (ShaclCorePropertyShape) {
-    function $filter(filter, value) {
-        if (!BaseShaclCoreShapeStatic.$filter(filter, value)) {
-            return false;
-        }
-        if (filter.defaultValue !== undefined &&
-            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
-            return false;
-        }
-        if (filter.descriptions !== undefined &&
-            !$filterArray($filterString)(filter.descriptions, value.descriptions)) {
-            return false;
-        }
-        if (filter.groups !== undefined &&
-            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
-            return false;
-        }
-        if (filter.names !== undefined &&
-            !$filterArray($filterString)(filter.names, value.names)) {
-            return false;
-        }
-        if (filter.order !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
-            return false;
-        }
-        if (filter.path !== undefined &&
-            !PropertyPath.$filter(filter.path, value.path)) {
-            return false;
-        }
-        if (filter.uniqueLang !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
-            return false;
-        }
-        return true;
-    }
-    ShaclCorePropertyShape.$filter = $filter;
-    ShaclCorePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = ShaclCorePropertyShape.$Identifier || (ShaclCorePropertyShape.$Identifier = {}));
-    function isShaclCorePropertyShape(object) {
-        switch (object.$type) {
-            case "ShaclCorePropertyShape":
-                return true;
-            default:
-                return false;
-        }
-    }
-    ShaclCorePropertyShape.isShaclCorePropertyShape = isShaclCorePropertyShape;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
-        if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
-        }
-        return ShaclCorePropertyShape.$propertiesFromRdf({
-            context,
-            ignoreRdfType,
-            objectSet,
-            preferredLanguages,
-            resource,
-        });
-    }
-    ShaclCorePropertyShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf($parameters) {
-        return BaseShaclCoreShapeStatic.$propertiesFromRdf({
-            ...$parameters,
-            ignoreRdfType: true,
-        }).chain(($super0) => (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#PropertyShape":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(ShaclCorePropertyShape.$fromRdfType, { graph: $parameters.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)`));
-            })
-            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $parameters.resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
-        }).toValues())
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .chain((values) => values.head())
-            .chain(($identifier) => Right("ShaclCorePropertyShape").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.defaultValue,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                switch (term.termType) {
-                    case "NamedNode":
-                    case "Literal":
-                        return Either.of(term);
-                    default:
-                        return Left(new Resource.MistypedTermValueError({
-                            actualValue: term,
-                            expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $parameters.resource,
-                            propertyPath: ShaclCorePropertyShape.$schema.properties
-                                .defaultValue.path,
-                        }));
-                }
-            })))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: ShaclCorePropertyShape.$schema.properties
-                        .defaultValue.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((defaultValue) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.descriptions,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: ShaclCorePropertyShape.$schema.properties
-                    .descriptions.path,
-                value: valuesArray,
-            })),
-        }).chain((descriptions) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.groups,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: ShaclCorePropertyShape.$schema.properties.groups
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((groups) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.names,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: ShaclCorePropertyShape.$schema.properties.names
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((names) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.order,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toFloat()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: ShaclCorePropertyShape.$schema.properties
-                        .order.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((order) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.path,
-            typeFromRdf: (resourceValues) => resourceValues.chain((values) => values.chainMap((value) => value.toResource().chain((resource) => PropertyPath.$fromRdf(resource, {
-                context: $parameters.context,
-                ignoreRdfType: true,
-                objectSet: $parameters.objectSet,
-                preferredLanguages: $parameters.preferredLanguages,
-            })))),
-        }).chain((path) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyShape.$schema.properties.uniqueLang,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $parameters.resource,
-                    propertyPath: ShaclCorePropertyShape.$schema
-                        .properties.uniqueLang.path,
-                    value: Maybe.empty(),
-                })),
-        }).map((uniqueLang) => ({
-            ...$super0,
-            $identifier,
-            $type,
-            defaultValue,
-            descriptions,
-            groups,
-            names,
-            order,
-            path,
-            uniqueLang,
-        }))))))))))));
-    }
-    ShaclCorePropertyShape.$propertiesFromRdf = $propertiesFromRdf;
-    function $toRdf(_shaclCorePropertyShape, options) {
+    function $toRdfResource(_propertyShape, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCorePropertyShape, {
-            ignoreRdfType: true,
-            graph: options?.graph,
-            resourceSet,
-        });
+        const resource = resourceSet.resource(_propertyShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), options?.graph);
         }
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), _shaclCorePropertyShape.defaultValue.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), _shaclCorePropertyShape.descriptions.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), _shaclCorePropertyShape.groups.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), _shaclCorePropertyShape.names.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), _shaclCorePropertyShape.order
-            .toList()
-            .flatMap((value) => [
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _propertyShape.and.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), _propertyShape.classes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _propertyShape.comments.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), _propertyShape.datatype.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), _propertyShape.deactivated
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), _propertyShape.defaultValue.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), _propertyShape.descriptions.flatMap((item) => [
+            $literalFactory.string(item),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), _propertyShape.flags.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), _propertyShape.groups.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), _propertyShape.hasValues.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), _propertyShape.in_.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), _propertyShape.isDefinedBy.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _propertyShape.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), _propertyShape.languageIn.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), _propertyShape.maxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), _propertyShape.maxExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), _propertyShape.maxInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), _propertyShape.maxLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), _propertyShape.minCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), _propertyShape.minExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), _propertyShape.minInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), _propertyShape.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), _propertyShape.names.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _propertyShape.nodeKind.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _propertyShape.nodes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _propertyShape.not.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), _propertyShape.order
+            .toList()
+            .flatMap((value) => [
             $literalFactory.number(value, $RdfVocabularies.xsd.double),
         ]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), [
-            PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+            $PropertyPath.$toRdfResource(_propertyShape.path, {
                 graph: options?.graph,
                 resourceSet: resourceSet,
             }).identifier,
         ], options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), _shaclCorePropertyShape.uniqueLang
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _propertyShape.patterns.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), _propertyShape.uniqueLang
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _propertyShape.xone.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
         return resource;
     }
-    ShaclCorePropertyShape.$toRdf = $toRdf;
-    ShaclCorePropertyShape.$schema = {
-        properties: {
-            ...BaseShaclCoreShapeStatic.$schema.properties,
-            defaultValue: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Term" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
-            },
-            descriptions: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
-            },
-            groups: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
-            },
-            names: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
-            },
-            order: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Float" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
-            },
-            path: {
-                kind: "Shacl",
-                type: () => PropertyPath.$schema,
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
-            },
-            uniqueLang: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
-            },
-        },
-    };
-})(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
-export var ShaclCorePropertyGroup;
-(function (ShaclCorePropertyGroup) {
+    PropertyShape.$toRdfResource = $toRdfResource;
+})(PropertyShape || (PropertyShape = {}));
+export var PropertyGroup;
+(function (PropertyGroup) {
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = PropertyGroup.$Identifier || (PropertyGroup.$Identifier = {}));
     function $filter(filter, value) {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
@@ -1555,40 +1568,37 @@ export var ShaclCorePropertyGroup;
         }
         return true;
     }
-    ShaclCorePropertyGroup.$filter = $filter;
-    ShaclCorePropertyGroup.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = ShaclCorePropertyGroup.$Identifier || (ShaclCorePropertyGroup.$Identifier = {}));
-    function isShaclCorePropertyGroup(object) {
-        switch (object.$type) {
-            case "ShaclCorePropertyGroup":
-                return true;
-            default:
-                return false;
-        }
-    }
-    ShaclCorePropertyGroup.isShaclCorePropertyGroup = isShaclCorePropertyGroup;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    PropertyGroup.$filter = $filter;
+    PropertyGroup.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return ShaclCorePropertyGroup.$propertiesFromRdf({
+        return PropertyGroup.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
+    };
+    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) {
+            case "PropertyGroup":
+                return true;
+            default:
+                return false;
+        }
     }
-    ShaclCorePropertyGroup.$fromRdf = $fromRdf;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
+    PropertyGroup.isPropertyGroup = isPropertyGroup;
+    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
@@ -1597,75 +1607,60 @@ export var ShaclCorePropertyGroup;
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(ShaclCorePropertyGroup.$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("ShaclCorePropertyGroup").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyGroup.$schema.properties.comments,
+            .chain(($identifier) => Right("PropertyGroup").chain(($type) => $shaclPropertyFromRdf({
+            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,
-                propertyPath: ShaclCorePropertyGroup.$schema.properties.comments.path,
+                focusResource: $resource,
+                propertyPath: PropertyGroup.$schema.properties.comments.path,
                 value: valuesArray,
             })),
         }).chain((comments) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCorePropertyGroup.$schema.properties.labels,
+            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,
-                propertyPath: ShaclCorePropertyGroup.$schema.properties.labels.path,
+                focusResource: $resource,
+                propertyPath: PropertyGroup.$schema.properties.labels.path,
                 value: valuesArray,
             })),
         }).map((labels) => ({ $identifier, $type, comments, labels }))))));
-    }
-    ShaclCorePropertyGroup.$propertiesFromRdf = $propertiesFromRdf;
-    function $toRdf(_shaclCorePropertyGroup, options) {
-        const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = resourceSet.resource(_shaclCorePropertyGroup.$identifier);
-        if (!options?.ignoreRdfType) {
-            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
-        }
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _shaclCorePropertyGroup.comments.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _shaclCorePropertyGroup.labels.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), options?.graph);
-        return resource;
-    }
-    ShaclCorePropertyGroup.$toRdf = $toRdf;
-    ShaclCorePropertyGroup.$schema = {
+    };
+    PropertyGroup.$schema = {
         properties: {
             $identifier: {
                 kind: "Identifier",
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "TypeDiscriminant",
+                kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
-                    ownValues: ["ShaclCorePropertyGroup"],
+                    ownValues: ["PropertyGroup"],
                 }),
             },
             comments: {
@@ -1686,162 +1681,1317 @@ export var ShaclCorePropertyGroup;
             },
         },
     };
-})(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
-export var ShaclCoreNodeShape;
-(function (ShaclCoreNodeShape) {
-    function $filter(filter, value) {
-        if (!BaseShaclCoreShapeStatic.$filter(filter, value)) {
-            return false;
-        }
-        if (filter.closed !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.closed, value.closed)) {
-            return false;
-        }
-        if (filter.ignoredProperties !== undefined &&
-            !$filterMaybe($filterArray($filterIri))(filter.ignoredProperties, value.ignoredProperties)) {
-            return false;
-        }
-        if (filter.properties !== undefined &&
-            !$filterArray($filterIdentifier)(filter.properties, value.properties)) {
-            return false;
+    function $toRdfResource(_propertyGroup, options) {
+        const resourceSet = options?.resourceSet ??
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_propertyGroup.$identifier);
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
         }
-        return true;
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _propertyGroup.comments.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _propertyGroup.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        return resource;
     }
-    ShaclCoreNodeShape.$filter = $filter;
-    ShaclCoreNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
+    PropertyGroup.$toRdfResource = $toRdfResource;
+})(PropertyGroup || (PropertyGroup = {}));
+export var Ontology;
+(function (Ontology) {
     let $Identifier;
     (function ($Identifier) {
         $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
         $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = ShaclCoreNodeShape.$Identifier || (ShaclCoreNodeShape.$Identifier = {}));
-    function isShaclCoreNodeShape(object) {
-        switch (object.$type) {
-            case "ShaclCoreNodeShape":
-                return true;
-            default:
-                return false;
+    })($Identifier = Ontology.$Identifier || (Ontology.$Identifier = {}));
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.labels !== undefined &&
+            !$filterArray($filterString)(filter.labels, value.labels)) {
+            return false;
         }
+        return true;
     }
-    ShaclCoreNodeShape.isShaclCoreNodeShape = isShaclCoreNodeShape;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+    Ontology.$filter = $filter;
+    Ontology.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return ShaclCoreNodeShape.$propertiesFromRdf({
+        return Ontology.$propertiesFromRdfResource(resource, {
             context,
+            graph,
             ignoreRdfType,
             objectSet,
             preferredLanguages,
-            resource,
         });
-    }
-    ShaclCoreNodeShape.$fromRdf = $fromRdf;
-    function $propertiesFromRdf($parameters) {
-        return BaseShaclCoreShapeStatic.$propertiesFromRdf({
-            ...$parameters,
-            ignoreRdfType: true,
-        }).chain(($super0) => (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
+    };
+    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) {
+            case "Ontology":
+                return true;
+            default:
+                return false;
+        }
+    }
+    Ontology.isOntology = isOntology;
+    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
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/2002/07/owl#Ontology":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(Ontology.$fromRdfType, {
+                    graph: _$options.graph,
+                })) {
+                    return Right(true);
+                }
+                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: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues())
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.labels,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: Ontology.$schema.properties.labels.path,
+                value: valuesArray,
+            })),
+        }).map((labels) => ({ $identifier, $type, labels })))));
+    };
+    Ontology.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "Discriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["Ontology"],
+                }),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+        },
+    };
+    function $toRdfResource(_ontology, options) {
+        const resourceSet = options?.resourceSet ??
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_ontology.$identifier);
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
+        }
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _ontology.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        return resource;
+    }
+    Ontology.$toRdfResource = $toRdfResource;
+})(Ontology || (Ontology = {}));
+export var NodeShape;
+(function (NodeShape) {
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = NodeShape.$Identifier || (NodeShape.$Identifier = {}));
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.and !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.and, value.and)) {
+            return false;
+        }
+        if (filter.classes !== undefined &&
+            !$filterArray($filterIri)(filter.classes, value.classes)) {
+            return false;
+        }
+        if (filter.closed !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.closed, value.closed)) {
+            return false;
+        }
+        if (filter.comments !== undefined &&
+            !$filterArray($filterString)(filter.comments, value.comments)) {
+            return false;
+        }
+        if (filter.datatype !== undefined &&
+            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
+            return false;
+        }
+        if (filter.deactivated !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
+            return false;
+        }
+        if (filter.flags !== undefined &&
+            !$filterArray($filterString)(filter.flags, value.flags)) {
+            return false;
+        }
+        if (filter.hasValues !== undefined &&
+            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
+            return false;
+        }
+        if (filter.ignoredProperties !== undefined &&
+            !$filterMaybe($filterArray($filterIri))(filter.ignoredProperties, value.ignoredProperties)) {
+            return false;
+        }
+        if (filter.in_ !== undefined &&
+            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
+            return false;
+        }
+        if (filter.isDefinedBy !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
+            return false;
+        }
+        if (filter.labels !== undefined &&
+            !$filterArray($filterString)(filter.labels, value.labels)) {
+            return false;
+        }
+        if (filter.languageIn !== undefined &&
+            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
+            return false;
+        }
+        if (filter.maxCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
+            return false;
+        }
+        if (filter.maxExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
+            return false;
+        }
+        if (filter.maxInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
+            return false;
+        }
+        if (filter.maxLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
+            return false;
+        }
+        if (filter.minCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
+            return false;
+        }
+        if (filter.minExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
+            return false;
+        }
+        if (filter.minInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
+            return false;
+        }
+        if (filter.minLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
+            return false;
+        }
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+            return false;
+        }
+        if (filter.nodes !== undefined &&
+            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
+            return false;
+        }
+        if (filter.not !== undefined &&
+            !$filterArray($filterIdentifier)(filter.not, value.not)) {
+            return false;
+        }
+        if (filter.or !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
+            return false;
+        }
+        if (filter.patterns !== undefined &&
+            !$filterArray($filterString)(filter.patterns, value.patterns)) {
+            return false;
+        }
+        if (filter.properties !== undefined &&
+            !$filterArray($filterIdentifier)(filter.properties, value.properties)) {
+            return false;
+        }
+        if (filter.xone !== undefined &&
+            !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            return false;
+        }
+        return true;
+    }
+    NodeShape.$filter = $filter;
+    NodeShape.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        }
+        return NodeShape.$propertiesFromRdfResource(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            objectSet,
+            preferredLanguages,
+        });
+    };
+    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) {
+            case "NodeShape":
+                return true;
+            default:
+                return false;
+        }
+    }
+    NodeShape.isNodeShape = isNodeShape;
+    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
+                switch (actualRdfType.value) {
                     case "http://www.w3.org/ns/shacl#NodeShape":
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(ShaclCoreNodeShape.$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("ShaclCoreNodeShape").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCoreNodeShape.$schema.properties.closed,
+            .chain(($identifier) => Right("NodeShape").chain(($type) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.and,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                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: $resource,
+                propertyPath: PropertyShape.$schema.properties.and.path,
+                value: valuesArray,
+            })),
+        }).chain((and) => $shaclPropertyFromRdf({
+            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: $resource,
+                propertyPath: PropertyShape.$schema.properties.classes.path,
+                value: valuesArray,
+            })),
+        }).chain((classes) => $shaclPropertyFromRdf({
+            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,
-                    propertyPath: ShaclCoreNodeShape.$schema.properties.closed
-                        .path,
+                    focusResource: $resource,
+                    propertyPath: NodeShape.$schema.properties.closed.path,
                     value: Maybe.empty(),
                 })),
         }).chain((closed) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCoreNodeShape.$schema.properties.ignoredProperties,
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.comments,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({ graph: $parameters.graph })))
-                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $parameters.resource,
-                propertyPath: ShaclCoreNodeShape.$schema.properties
-                    .ignoredProperties.path,
-                values: valueList.toArray(),
-            })).chain((values) => values.chainMap((value) => value.toIri()))))
-                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.comments.path,
+                value: valuesArray,
+            })),
+        }).chain((comments) => $shaclPropertyFromRdf({
+            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,
-                    propertyPath: ShaclCoreNodeShape.$schema.properties
-                        .ignoredProperties.path,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.datatype
+                        .path,
                     value: Maybe.empty(),
                 })),
-        }).chain((ignoredProperties) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: ShaclCoreNodeShape.$schema.properties.properties,
+        }).chain((datatype) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.deactivated,
             typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .deactivated.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((deactivated) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.flags,
+            typeFromRdf: (resourceValues) => resourceValues
+                .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: ShaclCoreNodeShape.$schema.properties.properties
-                    .path,
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.flags.path,
                 value: valuesArray,
             })),
-        }).map((properties) => ({
-            ...$super0,
-            $identifier,
-            $type,
-            closed,
-            ignoredProperties,
-            properties,
-        }))))))));
-    }
-    ShaclCoreNodeShape.$propertiesFromRdf = $propertiesFromRdf;
-    function $toRdf(_shaclCoreNodeShape, options) {
+        }).chain((flags) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.hasValues,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $resource,
+                            propertyPath: PropertyShape.$schema
+                                .properties.hasValues.path,
+                        }));
+                }
+            })))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.hasValues
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((hasValues) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.ignoredProperties,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: NodeShape.$schema.properties
+                    .ignoredProperties.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIri()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: NodeShape.$schema.properties
+                        .ignoredProperties.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((ignoredProperties) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.in_,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: _$options.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
+                    .in_.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $resource,
+                            propertyPath: PropertyShape.$schema
+                                .properties.in_
+                                .path,
+                        }));
+                }
+            })))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .in_.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((in_) => $shaclPropertyFromRdf({
+            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: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .isDefinedBy.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((isDefinedBy) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.labels,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties
+                    .labels.path,
+                value: valuesArray,
+            })),
+        }).chain((labels) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.languageIn,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: _$options.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema
+                    .properties.languageIn
+                    .path,
+                values: valueList.toArray(),
+            }))
+                .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: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.languageIn
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((languageIn) => $shaclPropertyFromRdf({
+            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: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.maxCount
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxCount) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.maxExclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .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: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties
+                        .maxExclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxExclusive) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties.maxInclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .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: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties
+                        .maxInclusive.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxInclusive) => $shaclPropertyFromRdf({
+            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
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .maxLength.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((maxLength) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$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: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minCount.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minCount) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
+                .minExclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .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: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minExclusive
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minExclusive) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
+                .minInclusive,
+            typeFromRdf: (resourceValues) => resourceValues
+                .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: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minInclusive
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minInclusive) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
+                .minLength,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toInt()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .minLength
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((minLength) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
+                .nodeKind,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri([
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+            ])))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .nodeKind
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((nodeKind) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema.properties
+                .nodes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .nodes
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((nodes) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .not,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .not
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((not) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .or,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: _$options.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .or
+                    .path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .or
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((or) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .patterns,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .patterns
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((patterns) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .properties,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: NodeShape
+                    .$schema
+                    .properties
+                    .properties
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((properties) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .xone,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({
+                graph: _$options.graph,
+            })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .xone
+                    .path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .xone
+                    .path,
+                value: valuesArray,
+            })),
+        }).map((xone) => ({
+            $identifier,
+            $type,
+            and,
+            classes,
+            closed,
+            comments,
+            datatype,
+            deactivated,
+            flags,
+            hasValues,
+            ignoredProperties,
+            in_,
+            isDefinedBy,
+            labels,
+            languageIn,
+            maxCount,
+            maxExclusive,
+            maxInclusive,
+            maxLength,
+            minCount,
+            minExclusive,
+            minInclusive,
+            minLength,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            patterns,
+            properties,
+            xone,
+        }))))))))))))))))))))))))))))))));
+    };
+    NodeShape.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "Discriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["NodeShape"],
+                }),
+            },
+            and: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+            },
+            classes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+            },
+            closed: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+            },
+            comments: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            datatype: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+            },
+            deactivated: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Boolean" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+            },
+            flags: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+            },
+            hasValues: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Term" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+            },
+            ignoredProperties: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Iri" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+            },
+            in_: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Term" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+            },
+            labels: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+            languageIn: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "String" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+            },
+            maxCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+            },
+            maxLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+            },
+            minCount: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+            },
+            minExclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+            },
+            minInclusive: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Literal" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+            },
+            minLength: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Int" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+            },
+            nodeKind: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+            },
+            nodes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
+            not: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+            },
+            or: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+            },
+            patterns: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+            },
+            properties: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+            },
+            xone: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "List",
+                        item: () => ({ kind: "Identifier" }),
+                    }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+            },
+        },
+    };
+    function $toRdfResource(_nodeShape, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCoreNodeShape, {
-            ignoreRdfType: true,
-            graph: options?.graph,
-            resourceSet,
-        });
+        const resource = resourceSet.resource(_nodeShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), options?.graph);
         }
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), _shaclCoreNodeShape.closed
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _nodeShape.and.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), _nodeShape.classes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), _nodeShape.closed
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), _shaclCoreNodeShape.ignoredProperties.toList().flatMap((value) => [
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _nodeShape.comments.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), _nodeShape.datatype.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), _nodeShape.deactivated
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), _nodeShape.flags.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), _nodeShape.hasValues.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), _nodeShape.ignoredProperties.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), _nodeShape.in_.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), _nodeShape.isDefinedBy.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _nodeShape.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), _nodeShape.languageIn.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), _nodeShape.maxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), _nodeShape.maxExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), _nodeShape.maxInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), _nodeShape.maxLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), _nodeShape.minCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), _nodeShape.minExclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), _nodeShape.minInclusive.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), _nodeShape.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.unsignedInt),
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _nodeShape.nodeKind.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.nodes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _nodeShape.not.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = resourceSet.resource(dataFactory.blankNode());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, options?.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], options?.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, options?.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: resourceSet.resource(dataFactory.blankNode()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _nodeShape.patterns.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), _nodeShape.properties.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _nodeShape.xone.flatMap((item) => [
+            item.length > 0
+                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -1861,195 +3011,83 @@ export var ShaclCoreNodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), _shaclCoreNodeShape.properties.flatMap((item) => [item]), options?.graph);
         return resource;
     }
-    ShaclCoreNodeShape.$toRdf = $toRdf;
-    ShaclCoreNodeShape.$schema = {
-        properties: {
-            ...BaseShaclCoreShapeStatic.$schema.properties,
-            closed: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
-            },
-            ignoredProperties: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Iri" }),
-                    }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
-            },
-            properties: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
-            },
-        },
-    };
-})(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
-export var OwlOntology;
-(function (OwlOntology) {
-    function $filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier)) {
-            return false;
-        }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
-            return false;
-        }
-        return true;
-    }
-    OwlOntology.$filter = $filter;
-    OwlOntology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = OwlOntology.$Identifier || (OwlOntology.$Identifier = {}));
-    function isOwlOntology(object) {
-        switch (object.$type) {
-            case "OwlOntology":
-                return true;
-            default:
-                return false;
-        }
-    }
-    OwlOntology.isOwlOntology = isOwlOntology;
-    function $fromRdf(resource, options) {
-        let { context, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
-        if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+    NodeShape.$toRdfResource = $toRdfResource;
+})(NodeShape || (NodeShape = {}));
+export var Shape;
+(function (Shape) {
+    Shape.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
         }
-        return OwlOntology.$propertiesFromRdf({
-            context,
-            ignoreRdfType,
-            objectSet,
-            preferredLanguages,
-            resource,
-        });
-    }
-    OwlOntology.$fromRdf = $fromRdf;
-    function $propertiesFromRdf($parameters) {
-        return (!$parameters.ignoreRdfType
-            ? $parameters.resource
-                .value($RdfVocabularies.rdf.type, { graph: $parameters.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/2002/07/owl#Ontology":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($parameters.resource.isInstanceOf(OwlOntology.$fromRdfType, {
-                    graph: $parameters.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)`));
-            })
-            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $parameters.resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $parameters.resource.identifier,
-        }).toValues())
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .chain((values) => values.head())
-            .chain(($identifier) => Right("OwlOntology").chain(($type) => $shaclPropertyFromRdf({
-            graph: $parameters.graph,
-            resource: $parameters.resource,
-            propertySchema: OwlOntology.$schema.properties.labels,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, $parameters.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $parameters.resource,
-                propertyPath: OwlOntology.$schema.properties.labels.path,
-                value: valuesArray,
-            })),
-        }).map((labels) => ({ $identifier, $type, labels })))));
-    }
-    OwlOntology.$propertiesFromRdf = $propertiesFromRdf;
-    function $toRdf(_owlOntology, options) {
-        const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = resourceSet.resource(_owlOntology.$identifier);
-        if (!options?.ignoreRdfType) {
-            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
         }
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _owlOntology.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
-        return resource;
-    }
-    OwlOntology.$toRdf = $toRdf;
-    OwlOntology.$schema = {
-        properties: {
-            $identifier: {
-                kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "TypeDiscriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["OwlOntology"],
-                }),
-            },
-            labels: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
-            },
-        },
+        throw new Error("unrecognized type");
     };
-})(OwlOntology || (OwlOntology = {}));
-export var ShaclCoreShape;
-(function (ShaclCoreShape) {
-    function $filter(filter, value) {
+    Shape.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (ShaclCoreNodeShape.isShaclCoreNodeShape(value) &&
-            filter.on?.ShaclCoreNodeShape &&
-            !ShaclCoreNodeShape.$filter(filter.on.ShaclCoreNodeShape, value)) {
-            return false;
+        if (filter.on?.["NodeShape"] !== undefined &&
+            NodeShape.isNodeShape(value)) {
+            if (!NodeShape.$filter(filter.on["NodeShape"], value)) {
+                return false;
+            }
         }
-        if (ShaclCorePropertyShape.isShaclCorePropertyShape(value) &&
-            filter.on?.ShaclCorePropertyShape &&
-            !ShaclCorePropertyShape.$filter(filter.on.ShaclCorePropertyShape, value)) {
-            return false;
+        if (filter.on?.["PropertyShape"] !== undefined &&
+            PropertyShape.isPropertyShape(value)) {
+            if (!PropertyShape.$filter(filter.on["PropertyShape"], value)) {
+                return false;
+            }
         }
         return true;
-    }
-    ShaclCoreShape.$filter = $filter;
+    };
+    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,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
+        })
+            .altLazy(() => PropertyShape.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
+            ignoreRdfType: false,
+            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 = ShaclCoreShape.$Identifier || (ShaclCoreShape.$Identifier = {}));
-    function isShaclCoreShape(object) {
-        return (ShaclCoreNodeShape.isShaclCoreNodeShape(object) ||
-            ShaclCorePropertyShape.isShaclCorePropertyShape(object));
-    }
-    ShaclCoreShape.isShaclCoreShape = isShaclCoreShape;
-    ShaclCoreShape.$schema = {
+    })($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",
@@ -2278,68 +3316,152 @@ export var ShaclCoreShape;
             },
         },
     };
-    function $fromRdf(resource, options) {
-        return ShaclCoreNodeShape.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        }).altLazy(() => ShaclCorePropertyShape.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        }));
-    }
-    ShaclCoreShape.$fromRdf = $fromRdf;
-    function $toRdf(_shaclCoreShape, _parameters) {
-        if (ShaclCoreNodeShape.isShaclCoreNodeShape(_shaclCoreShape)) {
-            return ShaclCoreNodeShape.$toRdf(_shaclCoreShape, _parameters);
+    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.isShape = isShape;
+})(Shape || (Shape = {}));
+export var $Object;
+(function ($Object) {
+    $Object.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
+        }
+        if (Ontology.isOntology(value)) {
+            return Ontology.$toRdfResource(value, options);
         }
-        if (ShaclCorePropertyShape.isShaclCorePropertyShape(_shaclCoreShape)) {
-            return ShaclCorePropertyShape.$toRdf(_shaclCoreShape, _parameters);
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return PropertyGroup.$toRdfResource(value, options);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
         }
         throw new Error("unrecognized type");
-    }
-    ShaclCoreShape.$toRdf = $toRdf;
-})(ShaclCoreShape || (ShaclCoreShape = {}));
-export var $Object;
-(function ($Object) {
-    function $filter(filter, value) {
+    };
+    $Object.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (OwlOntology.isOwlOntology(value) &&
-            filter.on?.OwlOntology &&
-            !OwlOntology.$filter(filter.on.OwlOntology, value)) {
-            return false;
-        }
-        if (ShaclCoreNodeShape.isShaclCoreNodeShape(value) &&
-            filter.on?.ShaclCoreNodeShape &&
-            !ShaclCoreNodeShape.$filter(filter.on.ShaclCoreNodeShape, value)) {
-            return false;
+        if (filter.on?.["NodeShape"] !== undefined &&
+            NodeShape.isNodeShape(value)) {
+            if (!NodeShape.$filter(filter.on["NodeShape"], value)) {
+                return false;
+            }
         }
-        if (ShaclCorePropertyGroup.isShaclCorePropertyGroup(value) &&
-            filter.on?.ShaclCorePropertyGroup &&
-            !ShaclCorePropertyGroup.$filter(filter.on.ShaclCorePropertyGroup, value)) {
-            return false;
+        if (filter.on?.["Ontology"] !== undefined && Ontology.isOntology(value)) {
+            if (!Ontology.$filter(filter.on["Ontology"], value)) {
+                return false;
+            }
         }
-        if (ShaclCorePropertyShape.isShaclCorePropertyShape(value) &&
-            filter.on?.ShaclCorePropertyShape &&
-            !ShaclCorePropertyShape.$filter(filter.on.ShaclCorePropertyShape, value)) {
-            return false;
+        if (filter.on?.["PropertyGroup"] !== undefined &&
+            PropertyGroup.isPropertyGroup(value)) {
+            if (!PropertyGroup.$filter(filter.on["PropertyGroup"], value)) {
+                return false;
+            }
         }
-        if (BaseShaclCoreShapeStatic.isBaseShaclCoreShape(value) &&
-            filter.on?.BaseShaclCoreShape &&
-            !BaseShaclCoreShapeStatic.$filter(filter.on.BaseShaclCoreShape, 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;
+    };
+    $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.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
+            ignoreRdfType: false,
+            objectSet: _options.objectSet,
+            preferredLanguages: _options.preferredLanguages,
+            propertyPath: _options.propertyPath,
+            resource: _options.resource,
+        }))
+            .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.$fromRdfResourceValues(valueAsValues, {
+            context: _options.context,
+            graph: _options.graph,
+            ignoreRdfType: false,
+            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",
@@ -2351,41 +3473,41 @@ export var $Object;
             },
         },
     };
-    function $fromRdf(resource, options) {
-        return OwlOntology.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        })
-            .altLazy(() => ShaclCoreNodeShape.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        }))
-            .altLazy(() => ShaclCorePropertyGroup.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        }))
-            .altLazy(() => ShaclCorePropertyShape.$fromRdf(resource, {
-            ...options,
-            ignoreRdfType: false,
-        }));
-    }
-    $Object.$fromRdf = $fromRdf;
-    function $toRdf(_object, _parameters) {
-        if (OwlOntology.isOwlOntology(_object)) {
-            return OwlOntology.$toRdf(_object, _parameters);
-        }
-        if (ShaclCoreNodeShape.isShaclCoreNodeShape(_object)) {
-            return ShaclCoreNodeShape.$toRdf(_object, _parameters);
-        }
-        if (ShaclCorePropertyGroup.isShaclCorePropertyGroup(_object)) {
-            return ShaclCorePropertyGroup.$toRdf(_object, _parameters);
-        }
-        if (ShaclCorePropertyShape.isShaclCorePropertyShape(_object)) {
-            return ShaclCorePropertyShape.$toRdf(_object, _parameters);
-        }
-        throw new Error("unrecognized type");
-    }
-    $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;
@@ -2403,158 +3525,176 @@ export class $RdfjsDatasetObjectSet {
     $resourceSet() {
         return new ResourceSet(this.$dataset(), { dataFactory: dataFactory });
     }
-    async owlOntology(identifier) {
-        return this.owlOntologySync(identifier);
+    async nodeShape(identifier, options) {
+        return this.nodeShapeSync(identifier, options);
     }
-    owlOntologySync(identifier) {
-        return this.owlOntologiesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    nodeShapeSync(identifier, options) {
+        return this.nodeShapesSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
-    async owlOntologyCount(query) {
-        return this.owlOntologyCountSync(query);
+    async nodeShapeCount(query) {
+        return this.nodeShapeCountSync(query);
     }
-    owlOntologyCountSync(query) {
-        return this.owlOntologiesSync(query).map((objects) => objects.length);
+    nodeShapeCountSync(query) {
+        return this.nodeShapesSync(query).map((objects) => objects.length);
     }
-    async owlOntologyIdentifiers(query) {
-        return this.owlOntologyIdentifiersSync(query);
+    async nodeShapeIdentifiers(query) {
+        return this.nodeShapeIdentifiersSync(query);
     }
-    owlOntologyIdentifiersSync(query) {
-        return this.owlOntologiesSync(query).map((objects) => objects.map((object) => object.$identifier));
+    nodeShapeIdentifiersSync(query) {
+        return this.nodeShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
-    async owlOntologies(query) {
-        return this.owlOntologiesSync(query);
+    async nodeShapes(query) {
+        return this.nodeShapesSync(query);
     }
-    owlOntologiesSync(query) {
+    nodeShapesSync(query) {
         return this.$objectsSync({
-            $filter: OwlOntology.$filter,
-            $fromRdf: OwlOntology.$fromRdf,
-            $fromRdfTypes: [OwlOntology.$fromRdfType],
+            $filter: NodeShape.$filter,
+            $fromRdfResource: NodeShape.$fromRdfResource,
+            $fromRdfTypes: [NodeShape.$fromRdfType],
         }, query);
     }
-    async shaclCoreNodeShape(identifier) {
-        return this.shaclCoreNodeShapeSync(identifier);
+    async ontology(identifier, options) {
+        return this.ontologySync(identifier, options);
     }
-    shaclCoreNodeShapeSync(identifier) {
-        return this.shaclCoreNodeShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    ontologySync(identifier, options) {
+        return this.ontologiesSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
-    async shaclCoreNodeShapeCount(query) {
-        return this.shaclCoreNodeShapeCountSync(query);
+    async ontologyCount(query) {
+        return this.ontologyCountSync(query);
     }
-    shaclCoreNodeShapeCountSync(query) {
-        return this.shaclCoreNodeShapesSync(query).map((objects) => objects.length);
+    ontologyCountSync(query) {
+        return this.ontologiesSync(query).map((objects) => objects.length);
     }
-    async shaclCoreNodeShapeIdentifiers(query) {
-        return this.shaclCoreNodeShapeIdentifiersSync(query);
+    async ontologyIdentifiers(query) {
+        return this.ontologyIdentifiersSync(query);
     }
-    shaclCoreNodeShapeIdentifiersSync(query) {
-        return this.shaclCoreNodeShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
+    ontologyIdentifiersSync(query) {
+        return this.ontologiesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
-    async shaclCoreNodeShapes(query) {
-        return this.shaclCoreNodeShapesSync(query);
+    async ontologies(query) {
+        return this.ontologiesSync(query);
     }
-    shaclCoreNodeShapesSync(query) {
+    ontologiesSync(query) {
         return this.$objectsSync({
-            $filter: ShaclCoreNodeShape.$filter,
-            $fromRdf: ShaclCoreNodeShape.$fromRdf,
-            $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+            $filter: Ontology.$filter,
+            $fromRdfResource: Ontology.$fromRdfResource,
+            $fromRdfTypes: [Ontology.$fromRdfType],
         }, query);
     }
-    async shaclCorePropertyGroup(identifier) {
-        return this.shaclCorePropertyGroupSync(identifier);
+    async propertyGroup(identifier, options) {
+        return this.propertyGroupSync(identifier, options);
     }
-    shaclCorePropertyGroupSync(identifier) {
-        return this.shaclCorePropertyGroupsSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    propertyGroupSync(identifier, options) {
+        return this.propertyGroupsSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
-    async shaclCorePropertyGroupCount(query) {
-        return this.shaclCorePropertyGroupCountSync(query);
+    async propertyGroupCount(query) {
+        return this.propertyGroupCountSync(query);
     }
-    shaclCorePropertyGroupCountSync(query) {
-        return this.shaclCorePropertyGroupsSync(query).map((objects) => objects.length);
+    propertyGroupCountSync(query) {
+        return this.propertyGroupsSync(query).map((objects) => objects.length);
     }
-    async shaclCorePropertyGroupIdentifiers(query) {
-        return this.shaclCorePropertyGroupIdentifiersSync(query);
+    async propertyGroupIdentifiers(query) {
+        return this.propertyGroupIdentifiersSync(query);
     }
-    shaclCorePropertyGroupIdentifiersSync(query) {
-        return this.shaclCorePropertyGroupsSync(query).map((objects) => objects.map((object) => object.$identifier));
+    propertyGroupIdentifiersSync(query) {
+        return this.propertyGroupsSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
-    async shaclCorePropertyGroups(query) {
-        return this.shaclCorePropertyGroupsSync(query);
+    async propertyGroups(query) {
+        return this.propertyGroupsSync(query);
     }
-    shaclCorePropertyGroupsSync(query) {
+    propertyGroupsSync(query) {
         return this.$objectsSync({
-            $filter: ShaclCorePropertyGroup.$filter,
-            $fromRdf: ShaclCorePropertyGroup.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+            $filter: PropertyGroup.$filter,
+            $fromRdfResource: PropertyGroup.$fromRdfResource,
+            $fromRdfTypes: [PropertyGroup.$fromRdfType],
         }, query);
     }
-    async shaclCorePropertyShape(identifier) {
-        return this.shaclCorePropertyShapeSync(identifier);
+    async propertyShape(identifier, options) {
+        return this.propertyShapeSync(identifier, options);
     }
-    shaclCorePropertyShapeSync(identifier) {
-        return this.shaclCorePropertyShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    propertyShapeSync(identifier, options) {
+        return this.propertyShapesSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
-    async shaclCorePropertyShapeCount(query) {
-        return this.shaclCorePropertyShapeCountSync(query);
+    async propertyShapeCount(query) {
+        return this.propertyShapeCountSync(query);
     }
-    shaclCorePropertyShapeCountSync(query) {
-        return this.shaclCorePropertyShapesSync(query).map((objects) => objects.length);
+    propertyShapeCountSync(query) {
+        return this.propertyShapesSync(query).map((objects) => objects.length);
     }
-    async shaclCorePropertyShapeIdentifiers(query) {
-        return this.shaclCorePropertyShapeIdentifiersSync(query);
+    async propertyShapeIdentifiers(query) {
+        return this.propertyShapeIdentifiersSync(query);
     }
-    shaclCorePropertyShapeIdentifiersSync(query) {
-        return this.shaclCorePropertyShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
+    propertyShapeIdentifiersSync(query) {
+        return this.propertyShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
-    async shaclCorePropertyShapes(query) {
-        return this.shaclCorePropertyShapesSync(query);
+    async propertyShapes(query) {
+        return this.propertyShapesSync(query);
     }
-    shaclCorePropertyShapesSync(query) {
+    propertyShapesSync(query) {
         return this.$objectsSync({
-            $filter: ShaclCorePropertyShape.$filter,
-            $fromRdf: ShaclCorePropertyShape.$fromRdf,
-            $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+            $filter: PropertyShape.$filter,
+            $fromRdfResource: PropertyShape.$fromRdfResource,
+            $fromRdfTypes: [PropertyShape.$fromRdfType],
         }, query);
     }
-    async shaclCoreShape(identifier) {
-        return this.shaclCoreShapeSync(identifier);
+    async shape(identifier, options) {
+        return this.shapeSync(identifier, options);
     }
-    shaclCoreShapeSync(identifier) {
-        return this.shaclCoreShapesSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    shapeSync(identifier, options) {
+        return this.shapesSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
-    async shaclCoreShapeCount(query) {
-        return this.shaclCoreShapeCountSync(query);
+    async shapeCount(query) {
+        return this.shapeCountSync(query);
     }
-    shaclCoreShapeCountSync(query) {
-        return this.shaclCoreShapesSync(query).map((objects) => objects.length);
+    shapeCountSync(query) {
+        return this.shapesSync(query).map((objects) => objects.length);
     }
-    async shaclCoreShapeIdentifiers(query) {
-        return this.shaclCoreShapeIdentifiersSync(query);
+    async shapeIdentifiers(query) {
+        return this.shapeIdentifiersSync(query);
     }
-    shaclCoreShapeIdentifiersSync(query) {
-        return this.shaclCoreShapesSync(query).map((objects) => objects.map((object) => object.$identifier));
+    shapeIdentifiersSync(query) {
+        return this.shapesSync(query).map((objects) => objects.map((object) => object.$identifier));
     }
-    async shaclCoreShapes(query) {
-        return this.shaclCoreShapesSync(query);
+    async shapes(query) {
+        return this.shapesSync(query);
     }
-    shaclCoreShapesSync(query) {
+    shapesSync(query) {
         return this.$objectUnionsSync([
             {
-                $filter: ShaclCoreShape.$filter,
-                $fromRdf: ShaclCoreNodeShape.$fromRdf,
-                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+                $filter: Shape.$filter,
+                $fromRdfResource: NodeShape.$fromRdfResource,
+                $fromRdfTypes: [NodeShape.$fromRdfType],
             },
             {
-                $filter: ShaclCoreShape.$filter,
-                $fromRdf: ShaclCorePropertyShape.$fromRdf,
-                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+                $filter: Shape.$filter,
+                $fromRdfResource: PropertyShape.$fromRdfResource,
+                $fromRdfTypes: [PropertyShape.$fromRdfType],
             },
         ], query);
     }
-    async object(identifier) {
-        return this.objectSync(identifier);
+    async object(identifier, options) {
+        return this.objectSync(identifier, options);
     }
-    objectSync(identifier) {
-        return this.objectsSync({ identifiers: [identifier] }).map((objects) => objects[0]);
+    objectSync(identifier, options) {
+        return this.objectsSync({
+            identifiers: [identifier],
+            preferredLanguages: options?.preferredLanguages,
+        }).map((objects) => objects[0]);
     }
     async objectCount(query) {
         return this.objectCountSync(query);
@@ -2575,23 +3715,23 @@ export class $RdfjsDatasetObjectSet {
         return this.$objectUnionsSync([
             {
                 $filter: $Object.$filter,
-                $fromRdf: OwlOntology.$fromRdf,
-                $fromRdfTypes: [OwlOntology.$fromRdfType],
+                $fromRdfResource: NodeShape.$fromRdfResource,
+                $fromRdfTypes: [NodeShape.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: ShaclCoreNodeShape.$fromRdf,
-                $fromRdfTypes: [ShaclCoreNodeShape.$fromRdfType],
+                $fromRdfResource: Ontology.$fromRdfResource,
+                $fromRdfTypes: [Ontology.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: ShaclCorePropertyGroup.$fromRdf,
-                $fromRdfTypes: [ShaclCorePropertyGroup.$fromRdfType],
+                $fromRdfResource: PropertyGroup.$fromRdfResource,
+                $fromRdfTypes: [PropertyGroup.$fromRdfType],
             },
             {
                 $filter: $Object.$filter,
-                $fromRdf: ShaclCorePropertyShape.$fromRdf,
-                $fromRdfTypes: [ShaclCorePropertyShape.$fromRdfType],
+                $fromRdfResource: PropertyShape.$fromRdfResource,
+                $fromRdfTypes: [PropertyShape.$fromRdfType],
             },
         ], query);
     }
@@ -2605,6 +3745,11 @@ export class $RdfjsDatasetObjectSet {
         if (offset < 0) {
             offset = 0;
         }
+        const fromRdfResourceOptions = {
+            graph,
+            objectSet: this,
+            preferredLanguages: query?.preferredLanguages,
+        };
         let resources;
         const resourceSet = this.$resourceSet(); // Access once, in case it's instantiated lazily
         let sortResources;
@@ -2651,7 +3796,7 @@ export class $RdfjsDatasetObjectSet {
                 const resource = resourceSet.resource(quad.subject);
                 // Eagerly eliminate the majority of resources that won't match the object type
                 objectType
-                    .$fromRdf(resource, { graph, objectSet: this })
+                    .$fromRdfResource(resource, fromRdfResourceOptions)
                     .ifRight((object) => {
                     resources.push({ object, resource });
                 });
@@ -2665,10 +3810,7 @@ export class $RdfjsDatasetObjectSet {
         const objects = [];
         for (let { object, resource } of resources) {
             if (!object) {
-                const objectEither = objectType.$fromRdf(resource, {
-                    graph,
-                    objectSet: this,
-                });
+                const objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 if (objectEither.isLeft()) {
                     return objectEither;
                 }
@@ -2696,6 +3838,11 @@ export class $RdfjsDatasetObjectSet {
         if (offset < 0) {
             offset = 0;
         }
+        const fromRdfResourceOptions = {
+            graph,
+            objectSet: this,
+            preferredLanguages: query?.preferredLanguages,
+        };
         let resources;
         const resourceSet = this.$resourceSet(); // Access once, in case it's instantiated lazily
         let sortResources;
@@ -2745,7 +3892,7 @@ export class $RdfjsDatasetObjectSet {
                 const resource = resourceSet.resource(quad.subject);
                 for (const objectType of objectTypes) {
                     if (objectType
-                        .$fromRdf(resource, { graph, objectSet: this })
+                        .$fromRdfResource(resource, fromRdfResourceOptions)
                         .ifRight((object) => {
                         resources.push({ object, objectType, resource });
                     })
@@ -2765,18 +3912,12 @@ export class $RdfjsDatasetObjectSet {
             if (!object) {
                 let objectEither;
                 if (objectType) {
-                    objectEither = objectType.$fromRdf(resource, {
-                        graph,
-                        objectSet: this,
-                    });
+                    objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 }
                 else {
                     objectEither = Left(new Error("no object types"));
                     for (const tryObjectType of objectTypes) {
-                        objectEither = tryObjectType.$fromRdf(resource, {
-                            graph,
-                            objectSet: this,
-                        });
+                        objectEither = tryObjectType.$fromRdfResource(resource, fromRdfResourceOptions);
                         if (objectEither.isRight()) {
                             objectType = tryObjectType;
                             break;