@shaclmate/shacl-ast 4.0.13 → 4.0.15

package/dist/generated.js

@@ -162,6 +162,21 @@ class $IdentifierSet {
         }
     }
 }
+function $isReadonlyBigIntArray(x) {
+    return Array.isArray(x) && x.every((z) => typeof z === "bigint");
+}
+function $isReadonlyBooleanArray(x) {
+    return Array.isArray(x) && x.every((z) => typeof z === "boolean");
+}
+function $isReadonlyNumberArray(x) {
+    return Array.isArray(x) && x.every((z) => typeof z === "number");
+}
+function $isReadonlyObjectArray(x) {
+    return Array.isArray(x) && x.every((z) => typeof z === "object");
+}
+function $isReadonlyStringArray(x) {
+    return Array.isArray(x) && x.every((z) => typeof z === "string");
+}
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 export var $PropertyPath;
 (function ($PropertyPath) {
@@ -219,6 +234,576 @@ function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }
 }
 export var PropertyShape;
 (function (PropertyShape) {
+    function $create(parameters) {
+        let $identifier;
+        if (typeof parameters.$identifier === "object") {
+            $identifier = parameters.$identifier;
+        }
+        else if (typeof parameters.$identifier === "string") {
+            $identifier = dataFactory.namedNode(parameters.$identifier);
+        }
+        else if (parameters.$identifier === undefined) {
+            $identifier = dataFactory.blankNode();
+        }
+        else {
+            $identifier = parameters.$identifier;
+        }
+        const $type = "PropertyShape";
+        let and;
+        if (Maybe.isMaybe(parameters.and)) {
+            and = parameters.and;
+        }
+        else if ($isReadonlyObjectArray(parameters.and)) {
+            and = Maybe.of(parameters.and);
+        }
+        else if ($isReadonlyStringArray(parameters.and)) {
+            and = Maybe.of(parameters.and.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters.and === undefined) {
+            and = Maybe.empty();
+        }
+        else {
+            and = parameters.and;
+        }
+        let classes;
+        if (parameters.classes === undefined) {
+            classes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters.classes)) {
+            classes = parameters.classes;
+        }
+        else if ($isReadonlyStringArray(parameters.classes)) {
+            classes = parameters.classes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            classes = parameters.classes;
+        }
+        let comment;
+        if (Maybe.isMaybe(parameters.comment)) {
+            comment = parameters.comment;
+        }
+        else if (typeof parameters.comment === "string") {
+            comment = Maybe.of(parameters.comment);
+        }
+        else if (parameters.comment === undefined) {
+            comment = Maybe.empty();
+        }
+        else {
+            comment = parameters.comment;
+        }
+        let datatype;
+        if (Maybe.isMaybe(parameters.datatype)) {
+            datatype = parameters.datatype;
+        }
+        else if (typeof parameters.datatype === "object") {
+            datatype = Maybe.of(parameters.datatype);
+        }
+        else if (typeof parameters.datatype === "string") {
+            datatype = Maybe.of(dataFactory.namedNode(parameters.datatype));
+        }
+        else if (parameters.datatype === undefined) {
+            datatype = Maybe.empty();
+        }
+        else {
+            datatype = parameters.datatype;
+        }
+        let deactivated;
+        if (Maybe.isMaybe(parameters.deactivated)) {
+            deactivated = parameters.deactivated;
+        }
+        else if (typeof parameters.deactivated === "boolean") {
+            deactivated = Maybe.of(parameters.deactivated);
+        }
+        else if (parameters.deactivated === undefined) {
+            deactivated = Maybe.empty();
+        }
+        else {
+            deactivated = parameters.deactivated;
+        }
+        let defaultValue;
+        if (Maybe.isMaybe(parameters.defaultValue)) {
+            defaultValue = parameters.defaultValue;
+        }
+        else if (typeof parameters.defaultValue === "bigint") {
+            defaultValue = Maybe.of($literalFactory.bigint(parameters.defaultValue));
+        }
+        else if (typeof parameters.defaultValue === "boolean") {
+            defaultValue = Maybe.of($literalFactory.boolean(parameters.defaultValue));
+        }
+        else if (typeof parameters.defaultValue === "object" &&
+            parameters.defaultValue instanceof Date) {
+            defaultValue = Maybe.of($literalFactory.date(parameters.defaultValue));
+        }
+        else if (typeof parameters.defaultValue === "number") {
+            defaultValue = Maybe.of($literalFactory.number(parameters.defaultValue));
+        }
+        else if (typeof parameters.defaultValue === "string") {
+            defaultValue = Maybe.of($literalFactory.string(parameters.defaultValue));
+        }
+        else if (typeof parameters.defaultValue === "object") {
+            defaultValue = Maybe.of(parameters.defaultValue);
+        }
+        else if (parameters.defaultValue === undefined) {
+            defaultValue = Maybe.empty();
+        }
+        else {
+            defaultValue = parameters.defaultValue;
+        }
+        let description;
+        if (Maybe.isMaybe(parameters.description)) {
+            description = parameters.description;
+        }
+        else if (typeof parameters.description === "string") {
+            description = Maybe.of(parameters.description);
+        }
+        else if (parameters.description === undefined) {
+            description = Maybe.empty();
+        }
+        else {
+            description = parameters.description;
+        }
+        let flags;
+        if (parameters.flags === undefined) {
+            flags = [];
+        }
+        else if (typeof parameters.flags === "object") {
+            flags = parameters.flags;
+        }
+        else {
+            flags = parameters.flags;
+        }
+        let groups;
+        if (parameters.groups === undefined) {
+            groups = [];
+        }
+        else if ($isReadonlyObjectArray(parameters.groups)) {
+            groups = parameters.groups;
+        }
+        else if ($isReadonlyStringArray(parameters.groups)) {
+            groups = parameters.groups.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            groups = parameters.groups;
+        }
+        let hasValues;
+        if (parameters.hasValues === undefined) {
+            hasValues = [];
+        }
+        else if ($isReadonlyObjectArray(parameters.hasValues)) {
+            hasValues = parameters.hasValues;
+        }
+        else if ($isReadonlyBigIntArray(parameters.hasValues)) {
+            hasValues = parameters.hasValues.map((item) => $literalFactory.bigint(item));
+        }
+        else if ($isReadonlyBooleanArray(parameters.hasValues)) {
+            hasValues = parameters.hasValues.map((item) => $literalFactory.boolean(item));
+        }
+        else if ($isReadonlyNumberArray(parameters.hasValues)) {
+            hasValues = parameters.hasValues.map((item) => $literalFactory.number(item));
+        }
+        else if ($isReadonlyStringArray(parameters.hasValues)) {
+            hasValues = parameters.hasValues.map((item) => $literalFactory.string(item));
+        }
+        else {
+            hasValues = parameters.hasValues;
+        }
+        let in_;
+        if (Maybe.isMaybe(parameters.in_)) {
+            in_ = parameters.in_;
+        }
+        else if ($isReadonlyObjectArray(parameters.in_)) {
+            in_ = Maybe.of(parameters.in_);
+        }
+        else if ($isReadonlyBigIntArray(parameters.in_)) {
+            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.bigint(item)));
+        }
+        else if ($isReadonlyBooleanArray(parameters.in_)) {
+            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.boolean(item)));
+        }
+        else if ($isReadonlyNumberArray(parameters.in_)) {
+            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.number(item)));
+        }
+        else if ($isReadonlyStringArray(parameters.in_)) {
+            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.string(item)));
+        }
+        else if (parameters.in_ === undefined) {
+            in_ = Maybe.empty();
+        }
+        else {
+            in_ = parameters.in_;
+        }
+        let isDefinedBy;
+        if (Maybe.isMaybe(parameters.isDefinedBy)) {
+            isDefinedBy = parameters.isDefinedBy;
+        }
+        else if (typeof parameters.isDefinedBy === "object") {
+            isDefinedBy = Maybe.of(parameters.isDefinedBy);
+        }
+        else if (typeof parameters.isDefinedBy === "string") {
+            isDefinedBy = Maybe.of(dataFactory.namedNode(parameters.isDefinedBy));
+        }
+        else if (parameters.isDefinedBy === undefined) {
+            isDefinedBy = Maybe.empty();
+        }
+        else {
+            isDefinedBy = parameters.isDefinedBy;
+        }
+        let label;
+        if (Maybe.isMaybe(parameters.label)) {
+            label = parameters.label;
+        }
+        else if (typeof parameters.label === "string") {
+            label = Maybe.of(parameters.label);
+        }
+        else if (parameters.label === undefined) {
+            label = Maybe.empty();
+        }
+        else {
+            label = parameters.label;
+        }
+        let languageIn;
+        if (Maybe.isMaybe(parameters.languageIn)) {
+            languageIn = parameters.languageIn;
+        }
+        else if (typeof parameters.languageIn === "object") {
+            languageIn = Maybe.of(parameters.languageIn);
+        }
+        else if (parameters.languageIn === undefined) {
+            languageIn = Maybe.empty();
+        }
+        else {
+            languageIn = parameters.languageIn;
+        }
+        let maxCount;
+        if (Maybe.isMaybe(parameters.maxCount)) {
+            maxCount = parameters.maxCount;
+        }
+        else if (typeof parameters.maxCount === "number") {
+            maxCount = Maybe.of(parameters.maxCount);
+        }
+        else if (parameters.maxCount === undefined) {
+            maxCount = Maybe.empty();
+        }
+        else {
+            maxCount = parameters.maxCount;
+        }
+        let maxExclusive;
+        if (Maybe.isMaybe(parameters.maxExclusive)) {
+            maxExclusive = parameters.maxExclusive;
+        }
+        else if (typeof parameters.maxExclusive === "bigint") {
+            maxExclusive = Maybe.of($literalFactory.bigint(parameters.maxExclusive));
+        }
+        else if (typeof parameters.maxExclusive === "boolean") {
+            maxExclusive = Maybe.of($literalFactory.boolean(parameters.maxExclusive));
+        }
+        else if (typeof parameters.maxExclusive === "object" &&
+            parameters.maxExclusive instanceof Date) {
+            maxExclusive = Maybe.of($literalFactory.date(parameters.maxExclusive));
+        }
+        else if (typeof parameters.maxExclusive === "number") {
+            maxExclusive = Maybe.of($literalFactory.number(parameters.maxExclusive));
+        }
+        else if (typeof parameters.maxExclusive === "string") {
+            maxExclusive = Maybe.of($literalFactory.string(parameters.maxExclusive));
+        }
+        else if (typeof parameters.maxExclusive === "object") {
+            maxExclusive = Maybe.of(parameters.maxExclusive);
+        }
+        else if (parameters.maxExclusive === undefined) {
+            maxExclusive = Maybe.empty();
+        }
+        else {
+            maxExclusive = parameters.maxExclusive;
+        }
+        let maxInclusive;
+        if (Maybe.isMaybe(parameters.maxInclusive)) {
+            maxInclusive = parameters.maxInclusive;
+        }
+        else if (typeof parameters.maxInclusive === "bigint") {
+            maxInclusive = Maybe.of($literalFactory.bigint(parameters.maxInclusive));
+        }
+        else if (typeof parameters.maxInclusive === "boolean") {
+            maxInclusive = Maybe.of($literalFactory.boolean(parameters.maxInclusive));
+        }
+        else if (typeof parameters.maxInclusive === "object" &&
+            parameters.maxInclusive instanceof Date) {
+            maxInclusive = Maybe.of($literalFactory.date(parameters.maxInclusive));
+        }
+        else if (typeof parameters.maxInclusive === "number") {
+            maxInclusive = Maybe.of($literalFactory.number(parameters.maxInclusive));
+        }
+        else if (typeof parameters.maxInclusive === "string") {
+            maxInclusive = Maybe.of($literalFactory.string(parameters.maxInclusive));
+        }
+        else if (typeof parameters.maxInclusive === "object") {
+            maxInclusive = Maybe.of(parameters.maxInclusive);
+        }
+        else if (parameters.maxInclusive === undefined) {
+            maxInclusive = Maybe.empty();
+        }
+        else {
+            maxInclusive = parameters.maxInclusive;
+        }
+        let maxLength;
+        if (Maybe.isMaybe(parameters.maxLength)) {
+            maxLength = parameters.maxLength;
+        }
+        else if (typeof parameters.maxLength === "number") {
+            maxLength = Maybe.of(parameters.maxLength);
+        }
+        else if (parameters.maxLength === undefined) {
+            maxLength = Maybe.empty();
+        }
+        else {
+            maxLength = parameters.maxLength;
+        }
+        let minCount;
+        if (Maybe.isMaybe(parameters.minCount)) {
+            minCount = parameters.minCount;
+        }
+        else if (typeof parameters.minCount === "number") {
+            minCount = Maybe.of(parameters.minCount);
+        }
+        else if (parameters.minCount === undefined) {
+            minCount = Maybe.empty();
+        }
+        else {
+            minCount = parameters.minCount;
+        }
+        let minExclusive;
+        if (Maybe.isMaybe(parameters.minExclusive)) {
+            minExclusive = parameters.minExclusive;
+        }
+        else if (typeof parameters.minExclusive === "bigint") {
+            minExclusive = Maybe.of($literalFactory.bigint(parameters.minExclusive));
+        }
+        else if (typeof parameters.minExclusive === "boolean") {
+            minExclusive = Maybe.of($literalFactory.boolean(parameters.minExclusive));
+        }
+        else if (typeof parameters.minExclusive === "object" &&
+            parameters.minExclusive instanceof Date) {
+            minExclusive = Maybe.of($literalFactory.date(parameters.minExclusive));
+        }
+        else if (typeof parameters.minExclusive === "number") {
+            minExclusive = Maybe.of($literalFactory.number(parameters.minExclusive));
+        }
+        else if (typeof parameters.minExclusive === "string") {
+            minExclusive = Maybe.of($literalFactory.string(parameters.minExclusive));
+        }
+        else if (typeof parameters.minExclusive === "object") {
+            minExclusive = Maybe.of(parameters.minExclusive);
+        }
+        else if (parameters.minExclusive === undefined) {
+            minExclusive = Maybe.empty();
+        }
+        else {
+            minExclusive = parameters.minExclusive;
+        }
+        let minInclusive;
+        if (Maybe.isMaybe(parameters.minInclusive)) {
+            minInclusive = parameters.minInclusive;
+        }
+        else if (typeof parameters.minInclusive === "bigint") {
+            minInclusive = Maybe.of($literalFactory.bigint(parameters.minInclusive));
+        }
+        else if (typeof parameters.minInclusive === "boolean") {
+            minInclusive = Maybe.of($literalFactory.boolean(parameters.minInclusive));
+        }
+        else if (typeof parameters.minInclusive === "object" &&
+            parameters.minInclusive instanceof Date) {
+            minInclusive = Maybe.of($literalFactory.date(parameters.minInclusive));
+        }
+        else if (typeof parameters.minInclusive === "number") {
+            minInclusive = Maybe.of($literalFactory.number(parameters.minInclusive));
+        }
+        else if (typeof parameters.minInclusive === "string") {
+            minInclusive = Maybe.of($literalFactory.string(parameters.minInclusive));
+        }
+        else if (typeof parameters.minInclusive === "object") {
+            minInclusive = Maybe.of(parameters.minInclusive);
+        }
+        else if (parameters.minInclusive === undefined) {
+            minInclusive = Maybe.empty();
+        }
+        else {
+            minInclusive = parameters.minInclusive;
+        }
+        let minLength;
+        if (Maybe.isMaybe(parameters.minLength)) {
+            minLength = parameters.minLength;
+        }
+        else if (typeof parameters.minLength === "number") {
+            minLength = Maybe.of(parameters.minLength);
+        }
+        else if (parameters.minLength === undefined) {
+            minLength = Maybe.empty();
+        }
+        else {
+            minLength = parameters.minLength;
+        }
+        let name;
+        if (Maybe.isMaybe(parameters.name)) {
+            name = parameters.name;
+        }
+        else if (typeof parameters.name === "string") {
+            name = Maybe.of(parameters.name);
+        }
+        else if (parameters.name === undefined) {
+            name = Maybe.empty();
+        }
+        else {
+            name = parameters.name;
+        }
+        let nodeKind;
+        if (Maybe.isMaybe(parameters.nodeKind)) {
+            nodeKind = parameters.nodeKind;
+        }
+        else if (typeof parameters.nodeKind === "object") {
+            nodeKind = Maybe.of(parameters.nodeKind);
+        }
+        else if (typeof parameters.nodeKind === "string") {
+            nodeKind = Maybe.of(dataFactory.namedNode(parameters.nodeKind));
+        }
+        else if (parameters.nodeKind === undefined) {
+            nodeKind = Maybe.empty();
+        }
+        else {
+            nodeKind = parameters.nodeKind;
+        }
+        let nodes;
+        if (parameters.nodes === undefined) {
+            nodes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters.nodes)) {
+            nodes = parameters.nodes;
+        }
+        else if ($isReadonlyStringArray(parameters.nodes)) {
+            nodes = parameters.nodes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            nodes = parameters.nodes;
+        }
+        let not;
+        if (parameters.not === undefined) {
+            not = [];
+        }
+        else if ($isReadonlyObjectArray(parameters.not)) {
+            not = parameters.not;
+        }
+        else if ($isReadonlyStringArray(parameters.not)) {
+            not = parameters.not.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            not = parameters.not;
+        }
+        let or;
+        if (Maybe.isMaybe(parameters.or)) {
+            or = parameters.or;
+        }
+        else if ($isReadonlyObjectArray(parameters.or)) {
+            or = Maybe.of(parameters.or);
+        }
+        else if ($isReadonlyStringArray(parameters.or)) {
+            or = Maybe.of(parameters.or.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters.or === undefined) {
+            or = Maybe.empty();
+        }
+        else {
+            or = parameters.or;
+        }
+        let order;
+        if (Maybe.isMaybe(parameters.order)) {
+            order = parameters.order;
+        }
+        else if (typeof parameters.order === "number") {
+            order = Maybe.of(parameters.order);
+        }
+        else if (parameters.order === undefined) {
+            order = Maybe.empty();
+        }
+        else {
+            order = parameters.order;
+        }
+        const path = parameters.path;
+        let patterns;
+        if (parameters.patterns === undefined) {
+            patterns = [];
+        }
+        else if (typeof parameters.patterns === "object") {
+            patterns = parameters.patterns;
+        }
+        else {
+            patterns = parameters.patterns;
+        }
+        let uniqueLang;
+        if (Maybe.isMaybe(parameters.uniqueLang)) {
+            uniqueLang = parameters.uniqueLang;
+        }
+        else if (typeof parameters.uniqueLang === "boolean") {
+            uniqueLang = Maybe.of(parameters.uniqueLang);
+        }
+        else if (parameters.uniqueLang === undefined) {
+            uniqueLang = Maybe.empty();
+        }
+        else {
+            uniqueLang = parameters.uniqueLang;
+        }
+        let xone;
+        if (Maybe.isMaybe(parameters.xone)) {
+            xone = parameters.xone;
+        }
+        else if ($isReadonlyObjectArray(parameters.xone)) {
+            xone = Maybe.of(parameters.xone);
+        }
+        else if ($isReadonlyStringArray(parameters.xone)) {
+            xone = Maybe.of(parameters.xone.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters.xone === undefined) {
+            xone = Maybe.empty();
+        }
+        else {
+            xone = parameters.xone;
+        }
+        return {
+            $identifier,
+            $type,
+            and,
+            classes,
+            comment,
+            datatype,
+            deactivated,
+            defaultValue,
+            description,
+            flags,
+            groups,
+            hasValues,
+            in_,
+            isDefinedBy,
+            label,
+            languageIn,
+            maxCount,
+            maxExclusive,
+            maxInclusive,
+            maxLength,
+            minCount,
+            minExclusive,
+            minInclusive,
+            minLength,
+            name,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            order,
+            path,
+            patterns,
+            uniqueLang,
+            xone,
+        };
+    }
+    PropertyShape.$create = $create;
     let $Identifier;
     (function ($Identifier) {
         $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
@@ -230,15 +815,15 @@ export var PropertyShape;
             return false;
         }
         if (filter.and !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.and, value.and)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
             return false;
         }
         if (filter.classes !== undefined &&
             !$filterArray($filterIri)(filter.classes, value.classes)) {
             return false;
         }
-        if (filter.comments !== undefined &&
-            !$filterArray($filterString)(filter.comments, value.comments)) {
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
             return false;
         }
         if (filter.datatype !== undefined &&
@@ -253,8 +838,8 @@ export var PropertyShape;
             !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
             return false;
         }
-        if (filter.descriptions !== undefined &&
-            !$filterArray($filterString)(filter.descriptions, value.descriptions)) {
+        if (filter.description !== undefined &&
+            !$filterMaybe($filterString)(filter.description, value.description)) {
             return false;
         }
         if (filter.flags !== undefined &&
@@ -277,8 +862,8 @@ export var PropertyShape;
             !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
             return false;
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
             return false;
         }
         if (filter.languageIn !== undefined &&
@@ -317,8 +902,8 @@ export var PropertyShape;
             !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
             return false;
         }
-        if (filter.names !== undefined &&
-            !$filterArray($filterString)(filter.names, value.names)) {
+        if (filter.name !== undefined &&
+            !$filterMaybe($filterString)(filter.name, value.name)) {
             return false;
         }
         if (filter.nodeKind !== undefined &&
@@ -334,7 +919,7 @@ export var PropertyShape;
             return false;
         }
         if (filter.or !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
             return false;
         }
         if (filter.order !== undefined &&
@@ -354,7 +939,7 @@ export var PropertyShape;
             return false;
         }
         if (filter.xone !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
             return false;
         }
         return true;
@@ -425,12 +1010,13 @@ export var PropertyShape;
                 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,
-            })),
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.and.path,
+                    value: Maybe.empty(),
+                })),
         }).chain((and) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
@@ -446,17 +1032,18 @@ export var PropertyShape;
         }).chain((classes) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.comments,
+            propertySchema: PropertyShape.$schema.properties.comment,
             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.comments.path,
-                value: valuesArray,
-            })),
-        }).chain((comments) => $shaclPropertyFromRdf({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.comment.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((comment) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema.properties.datatype,
@@ -515,18 +1102,19 @@ export var PropertyShape;
         }).chain((defaultValue) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.descriptions,
+            propertySchema: PropertyShape.$schema.properties.description,
             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({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .description.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((description) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema.properties.flags,
@@ -638,18 +1226,19 @@ export var PropertyShape;
         }).chain((isDefinedBy) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.labels,
+            propertySchema: PropertyShape.$schema.properties.label,
             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({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.label.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((label) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema.properties.languageIn,
@@ -818,21 +1407,23 @@ export var PropertyShape;
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema.properties
-                .names,
+                .name,
             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({
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .name
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((name) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema
@@ -915,16 +1506,18 @@ export var PropertyShape;
                 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,
-            })),
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .or
+                        .path,
+                    value: Maybe.empty(),
+                })),
         }).chain((or) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
@@ -1023,32 +1616,34 @@ export var PropertyShape;
                 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((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .xone
+                        .path,
+                    value: Maybe.empty(),
+                })),
         }).map((xone) => ({
             $identifier,
             $type,
             and,
             classes,
-            comments,
+            comment,
             datatype,
             deactivated,
             defaultValue,
-            descriptions,
+            description,
             flags,
             groups,
             hasValues,
             in_,
             isDefinedBy,
-            labels,
+            label,
             languageIn,
             maxCount,
             maxExclusive,
@@ -1058,7 +1653,7 @@ export var PropertyShape;
             minExclusive,
             minInclusive,
             minLength,
-            names,
+            name,
             nodeKind,
             nodes,
             not,
@@ -1086,7 +1681,7 @@ export var PropertyShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1102,10 +1697,10 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
             },
-            comments: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
@@ -1134,10 +1729,10 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
             },
-            descriptions: {
+            description: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
@@ -1185,10 +1780,10 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
             },
-            labels: {
+            label: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
@@ -1268,10 +1863,10 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
             },
-            names: {
+            name: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
@@ -1313,7 +1908,7 @@ export var PropertyShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1353,7 +1948,7 @@ export var PropertyShape;
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1370,9 +1965,9 @@ export var PropertyShape;
         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#and"), _propertyShape.and.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _propertyShape.and.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -1393,7 +1988,9 @@ export var PropertyShape;
                 : $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/2000/01/rdf-schema#comment"), _propertyShape.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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()
@@ -1401,9 +1998,9 @@ export var PropertyShape;
             $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#description"), _propertyShape.description
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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);
@@ -1430,7 +2027,9 @@ export var PropertyShape;
                 : $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/2000/01/rdf-schema#label"), _propertyShape.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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) => {
@@ -1477,13 +2076,15 @@ export var PropertyShape;
             .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#name"), _propertyShape.name
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -1520,9 +2121,9 @@ export var PropertyShape;
             .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) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _propertyShape.xone.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -1548,6 +2149,50 @@ export var PropertyShape;
 })(PropertyShape || (PropertyShape = {}));
 export var PropertyGroup;
 (function (PropertyGroup) {
+    function $create(parameters) {
+        let $identifier;
+        if (typeof parameters?.$identifier === "object") {
+            $identifier = parameters?.$identifier;
+        }
+        else if (typeof parameters?.$identifier === "string") {
+            $identifier = dataFactory.namedNode(parameters?.$identifier);
+        }
+        else if (parameters?.$identifier === undefined) {
+            $identifier = dataFactory.blankNode();
+        }
+        else {
+            $identifier = parameters?.$identifier;
+        }
+        const $type = "PropertyGroup";
+        let comment;
+        if (Maybe.isMaybe(parameters?.comment)) {
+            comment = parameters?.comment;
+        }
+        else if (typeof parameters?.comment === "string") {
+            comment = Maybe.of(parameters?.comment);
+        }
+        else if (parameters?.comment === undefined) {
+            comment = Maybe.empty();
+        }
+        else {
+            comment = parameters?.comment;
+        }
+        let label;
+        if (Maybe.isMaybe(parameters?.label)) {
+            label = parameters?.label;
+        }
+        else if (typeof parameters?.label === "string") {
+            label = Maybe.of(parameters?.label);
+        }
+        else if (parameters?.label === undefined) {
+            label = Maybe.empty();
+        }
+        else {
+            label = parameters?.label;
+        }
+        return { $identifier, $type, comment, label };
+    }
+    PropertyGroup.$create = $create;
     let $Identifier;
     (function ($Identifier) {
         $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
@@ -1558,12 +2203,12 @@ export var PropertyGroup;
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (filter.comments !== undefined &&
-            !$filterArray($filterString)(filter.comments, value.comments)) {
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
             return false;
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
             return false;
         }
         return true;
@@ -1625,30 +2270,32 @@ export var PropertyGroup;
             .chain(($identifier) => Right("PropertyGroup").chain(($type) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyGroup.$schema.properties.comments,
+            propertySchema: PropertyGroup.$schema.properties.comment,
             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: PropertyGroup.$schema.properties.comments.path,
-                value: valuesArray,
-            })),
-        }).chain((comments) => $shaclPropertyFromRdf({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.comment.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((comment) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyGroup.$schema.properties.labels,
+            propertySchema: PropertyGroup.$schema.properties.label,
             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: PropertyGroup.$schema.properties.labels.path,
-                value: valuesArray,
-            })),
-        }).map((labels) => ({ $identifier, $type, comments, labels }))))));
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.label.path,
+                    value: Maybe.empty(),
+                })),
+        }).map((label) => ({ $identifier, $type, comment, label }))))));
     };
     PropertyGroup.$schema = {
         properties: {
@@ -1663,18 +2310,18 @@ export var PropertyGroup;
                     ownValues: ["PropertyGroup"],
                 }),
             },
-            comments: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
             },
-            labels: {
+            label: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
@@ -1688,14 +2335,62 @@ export var PropertyGroup;
         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"), _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);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _propertyGroup.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _propertyGroup.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
         return resource;
     }
     PropertyGroup.$toRdfResource = $toRdfResource;
 })(PropertyGroup || (PropertyGroup = {}));
 export var Ontology;
 (function (Ontology) {
+    function $create(parameters) {
+        let $identifier;
+        if (typeof parameters?.$identifier === "object") {
+            $identifier = parameters?.$identifier;
+        }
+        else if (typeof parameters?.$identifier === "string") {
+            $identifier = dataFactory.namedNode(parameters?.$identifier);
+        }
+        else if (parameters?.$identifier === undefined) {
+            $identifier = dataFactory.blankNode();
+        }
+        else {
+            $identifier = parameters?.$identifier;
+        }
+        const $type = "Ontology";
+        let comment;
+        if (Maybe.isMaybe(parameters?.comment)) {
+            comment = parameters?.comment;
+        }
+        else if (typeof parameters?.comment === "string") {
+            comment = Maybe.of(parameters?.comment);
+        }
+        else if (parameters?.comment === undefined) {
+            comment = Maybe.empty();
+        }
+        else {
+            comment = parameters?.comment;
+        }
+        let label;
+        if (Maybe.isMaybe(parameters?.label)) {
+            label = parameters?.label;
+        }
+        else if (typeof parameters?.label === "string") {
+            label = Maybe.of(parameters?.label);
+        }
+        else if (parameters?.label === undefined) {
+            label = Maybe.empty();
+        }
+        else {
+            label = parameters?.label;
+        }
+        return { $identifier, $type, comment, label };
+    }
+    Ontology.$create = $create;
     let $Identifier;
     (function ($Identifier) {
         $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
@@ -1706,8 +2401,12 @@ export var Ontology;
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
             return false;
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
+        }
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
             return false;
         }
         return true;
@@ -1769,17 +2468,32 @@ export var Ontology;
             .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: Ontology.$schema.properties.labels,
+            propertySchema: Ontology.$schema.properties.comment,
             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 })))));
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.comment.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((comment) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.label,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                .chain((values) => values.chainMap((value) => value.toString()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.label.path,
+                    value: Maybe.empty(),
+                })),
+        }).map((label) => ({ $identifier, $type, comment, label }))))));
     };
     Ontology.$schema = {
         properties: {
@@ -1794,10 +2508,18 @@ export var Ontology;
                     ownValues: ["Ontology"],
                 }),
             },
-            labels: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            label: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
@@ -1811,13 +2533,559 @@ export var Ontology;
         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;
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _ontology.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _ontology.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        return resource;
+    }
+    Ontology.$toRdfResource = $toRdfResource;
+})(Ontology || (Ontology = {}));
+export var NodeShape;
+(function (NodeShape) {
+    function $create(parameters) {
+        let $identifier;
+        if (typeof parameters?.$identifier === "object") {
+            $identifier = parameters?.$identifier;
+        }
+        else if (typeof parameters?.$identifier === "string") {
+            $identifier = dataFactory.namedNode(parameters?.$identifier);
+        }
+        else if (parameters?.$identifier === undefined) {
+            $identifier = dataFactory.blankNode();
+        }
+        else {
+            $identifier = parameters?.$identifier;
+        }
+        const $type = "NodeShape";
+        let and;
+        if (Maybe.isMaybe(parameters?.and)) {
+            and = parameters?.and;
+        }
+        else if ($isReadonlyObjectArray(parameters?.and)) {
+            and = Maybe.of(parameters?.and);
+        }
+        else if ($isReadonlyStringArray(parameters?.and)) {
+            and = Maybe.of(parameters?.and.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters?.and === undefined) {
+            and = Maybe.empty();
+        }
+        else {
+            and = parameters?.and;
+        }
+        let classes;
+        if (parameters?.classes === undefined) {
+            classes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.classes)) {
+            classes = parameters?.classes;
+        }
+        else if ($isReadonlyStringArray(parameters?.classes)) {
+            classes = parameters?.classes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            classes = parameters?.classes;
+        }
+        let closed;
+        if (Maybe.isMaybe(parameters?.closed)) {
+            closed = parameters?.closed;
+        }
+        else if (typeof parameters?.closed === "boolean") {
+            closed = Maybe.of(parameters?.closed);
+        }
+        else if (parameters?.closed === undefined) {
+            closed = Maybe.empty();
+        }
+        else {
+            closed = parameters?.closed;
+        }
+        let comment;
+        if (Maybe.isMaybe(parameters?.comment)) {
+            comment = parameters?.comment;
+        }
+        else if (typeof parameters?.comment === "string") {
+            comment = Maybe.of(parameters?.comment);
+        }
+        else if (parameters?.comment === undefined) {
+            comment = Maybe.empty();
+        }
+        else {
+            comment = parameters?.comment;
+        }
+        let datatype;
+        if (Maybe.isMaybe(parameters?.datatype)) {
+            datatype = parameters?.datatype;
+        }
+        else if (typeof parameters?.datatype === "object") {
+            datatype = Maybe.of(parameters?.datatype);
+        }
+        else if (typeof parameters?.datatype === "string") {
+            datatype = Maybe.of(dataFactory.namedNode(parameters?.datatype));
+        }
+        else if (parameters?.datatype === undefined) {
+            datatype = Maybe.empty();
+        }
+        else {
+            datatype = parameters?.datatype;
+        }
+        let deactivated;
+        if (Maybe.isMaybe(parameters?.deactivated)) {
+            deactivated = parameters?.deactivated;
+        }
+        else if (typeof parameters?.deactivated === "boolean") {
+            deactivated = Maybe.of(parameters?.deactivated);
+        }
+        else if (parameters?.deactivated === undefined) {
+            deactivated = Maybe.empty();
+        }
+        else {
+            deactivated = parameters?.deactivated;
+        }
+        let flags;
+        if (parameters?.flags === undefined) {
+            flags = [];
+        }
+        else if (typeof parameters?.flags === "object") {
+            flags = parameters?.flags;
+        }
+        else {
+            flags = parameters?.flags;
+        }
+        let hasValues;
+        if (parameters?.hasValues === undefined) {
+            hasValues = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.hasValues)) {
+            hasValues = parameters?.hasValues;
+        }
+        else if ($isReadonlyBigIntArray(parameters?.hasValues)) {
+            hasValues = parameters?.hasValues.map((item) => $literalFactory.bigint(item));
+        }
+        else if ($isReadonlyBooleanArray(parameters?.hasValues)) {
+            hasValues = parameters?.hasValues.map((item) => $literalFactory.boolean(item));
+        }
+        else if ($isReadonlyNumberArray(parameters?.hasValues)) {
+            hasValues = parameters?.hasValues.map((item) => $literalFactory.number(item));
+        }
+        else if ($isReadonlyStringArray(parameters?.hasValues)) {
+            hasValues = parameters?.hasValues.map((item) => $literalFactory.string(item));
+        }
+        else {
+            hasValues = parameters?.hasValues;
+        }
+        let ignoredProperties;
+        if (Maybe.isMaybe(parameters?.ignoredProperties)) {
+            ignoredProperties = parameters?.ignoredProperties;
+        }
+        else if ($isReadonlyObjectArray(parameters?.ignoredProperties)) {
+            ignoredProperties = Maybe.of(parameters?.ignoredProperties);
+        }
+        else if ($isReadonlyStringArray(parameters?.ignoredProperties)) {
+            ignoredProperties = Maybe.of(parameters?.ignoredProperties.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters?.ignoredProperties === undefined) {
+            ignoredProperties = Maybe.empty();
+        }
+        else {
+            ignoredProperties = parameters?.ignoredProperties;
+        }
+        let in_;
+        if (Maybe.isMaybe(parameters?.in_)) {
+            in_ = parameters?.in_;
+        }
+        else if ($isReadonlyObjectArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_);
+        }
+        else if ($isReadonlyBigIntArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.bigint(item)));
+        }
+        else if ($isReadonlyBooleanArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.boolean(item)));
+        }
+        else if ($isReadonlyNumberArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.number(item)));
+        }
+        else if ($isReadonlyStringArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.string(item)));
+        }
+        else if (parameters?.in_ === undefined) {
+            in_ = Maybe.empty();
+        }
+        else {
+            in_ = parameters?.in_;
+        }
+        let isDefinedBy;
+        if (Maybe.isMaybe(parameters?.isDefinedBy)) {
+            isDefinedBy = parameters?.isDefinedBy;
+        }
+        else if (typeof parameters?.isDefinedBy === "object") {
+            isDefinedBy = Maybe.of(parameters?.isDefinedBy);
+        }
+        else if (typeof parameters?.isDefinedBy === "string") {
+            isDefinedBy = Maybe.of(dataFactory.namedNode(parameters?.isDefinedBy));
+        }
+        else if (parameters?.isDefinedBy === undefined) {
+            isDefinedBy = Maybe.empty();
+        }
+        else {
+            isDefinedBy = parameters?.isDefinedBy;
+        }
+        let label;
+        if (Maybe.isMaybe(parameters?.label)) {
+            label = parameters?.label;
+        }
+        else if (typeof parameters?.label === "string") {
+            label = Maybe.of(parameters?.label);
+        }
+        else if (parameters?.label === undefined) {
+            label = Maybe.empty();
+        }
+        else {
+            label = parameters?.label;
+        }
+        let languageIn;
+        if (Maybe.isMaybe(parameters?.languageIn)) {
+            languageIn = parameters?.languageIn;
+        }
+        else if (typeof parameters?.languageIn === "object") {
+            languageIn = Maybe.of(parameters?.languageIn);
+        }
+        else if (parameters?.languageIn === undefined) {
+            languageIn = Maybe.empty();
+        }
+        else {
+            languageIn = parameters?.languageIn;
+        }
+        let maxCount;
+        if (Maybe.isMaybe(parameters?.maxCount)) {
+            maxCount = parameters?.maxCount;
+        }
+        else if (typeof parameters?.maxCount === "number") {
+            maxCount = Maybe.of(parameters?.maxCount);
+        }
+        else if (parameters?.maxCount === undefined) {
+            maxCount = Maybe.empty();
+        }
+        else {
+            maxCount = parameters?.maxCount;
+        }
+        let maxExclusive;
+        if (Maybe.isMaybe(parameters?.maxExclusive)) {
+            maxExclusive = parameters?.maxExclusive;
+        }
+        else if (typeof parameters?.maxExclusive === "bigint") {
+            maxExclusive = Maybe.of($literalFactory.bigint(parameters?.maxExclusive));
+        }
+        else if (typeof parameters?.maxExclusive === "boolean") {
+            maxExclusive = Maybe.of($literalFactory.boolean(parameters?.maxExclusive));
+        }
+        else if (typeof parameters?.maxExclusive === "object" &&
+            parameters?.maxExclusive instanceof Date) {
+            maxExclusive = Maybe.of($literalFactory.date(parameters?.maxExclusive));
+        }
+        else if (typeof parameters?.maxExclusive === "number") {
+            maxExclusive = Maybe.of($literalFactory.number(parameters?.maxExclusive));
+        }
+        else if (typeof parameters?.maxExclusive === "string") {
+            maxExclusive = Maybe.of($literalFactory.string(parameters?.maxExclusive));
+        }
+        else if (typeof parameters?.maxExclusive === "object") {
+            maxExclusive = Maybe.of(parameters?.maxExclusive);
+        }
+        else if (parameters?.maxExclusive === undefined) {
+            maxExclusive = Maybe.empty();
+        }
+        else {
+            maxExclusive = parameters?.maxExclusive;
+        }
+        let maxInclusive;
+        if (Maybe.isMaybe(parameters?.maxInclusive)) {
+            maxInclusive = parameters?.maxInclusive;
+        }
+        else if (typeof parameters?.maxInclusive === "bigint") {
+            maxInclusive = Maybe.of($literalFactory.bigint(parameters?.maxInclusive));
+        }
+        else if (typeof parameters?.maxInclusive === "boolean") {
+            maxInclusive = Maybe.of($literalFactory.boolean(parameters?.maxInclusive));
+        }
+        else if (typeof parameters?.maxInclusive === "object" &&
+            parameters?.maxInclusive instanceof Date) {
+            maxInclusive = Maybe.of($literalFactory.date(parameters?.maxInclusive));
+        }
+        else if (typeof parameters?.maxInclusive === "number") {
+            maxInclusive = Maybe.of($literalFactory.number(parameters?.maxInclusive));
+        }
+        else if (typeof parameters?.maxInclusive === "string") {
+            maxInclusive = Maybe.of($literalFactory.string(parameters?.maxInclusive));
+        }
+        else if (typeof parameters?.maxInclusive === "object") {
+            maxInclusive = Maybe.of(parameters?.maxInclusive);
+        }
+        else if (parameters?.maxInclusive === undefined) {
+            maxInclusive = Maybe.empty();
+        }
+        else {
+            maxInclusive = parameters?.maxInclusive;
+        }
+        let maxLength;
+        if (Maybe.isMaybe(parameters?.maxLength)) {
+            maxLength = parameters?.maxLength;
+        }
+        else if (typeof parameters?.maxLength === "number") {
+            maxLength = Maybe.of(parameters?.maxLength);
+        }
+        else if (parameters?.maxLength === undefined) {
+            maxLength = Maybe.empty();
+        }
+        else {
+            maxLength = parameters?.maxLength;
+        }
+        let minCount;
+        if (Maybe.isMaybe(parameters?.minCount)) {
+            minCount = parameters?.minCount;
+        }
+        else if (typeof parameters?.minCount === "number") {
+            minCount = Maybe.of(parameters?.minCount);
+        }
+        else if (parameters?.minCount === undefined) {
+            minCount = Maybe.empty();
+        }
+        else {
+            minCount = parameters?.minCount;
+        }
+        let minExclusive;
+        if (Maybe.isMaybe(parameters?.minExclusive)) {
+            minExclusive = parameters?.minExclusive;
+        }
+        else if (typeof parameters?.minExclusive === "bigint") {
+            minExclusive = Maybe.of($literalFactory.bigint(parameters?.minExclusive));
+        }
+        else if (typeof parameters?.minExclusive === "boolean") {
+            minExclusive = Maybe.of($literalFactory.boolean(parameters?.minExclusive));
+        }
+        else if (typeof parameters?.minExclusive === "object" &&
+            parameters?.minExclusive instanceof Date) {
+            minExclusive = Maybe.of($literalFactory.date(parameters?.minExclusive));
+        }
+        else if (typeof parameters?.minExclusive === "number") {
+            minExclusive = Maybe.of($literalFactory.number(parameters?.minExclusive));
+        }
+        else if (typeof parameters?.minExclusive === "string") {
+            minExclusive = Maybe.of($literalFactory.string(parameters?.minExclusive));
+        }
+        else if (typeof parameters?.minExclusive === "object") {
+            minExclusive = Maybe.of(parameters?.minExclusive);
+        }
+        else if (parameters?.minExclusive === undefined) {
+            minExclusive = Maybe.empty();
+        }
+        else {
+            minExclusive = parameters?.minExclusive;
+        }
+        let minInclusive;
+        if (Maybe.isMaybe(parameters?.minInclusive)) {
+            minInclusive = parameters?.minInclusive;
+        }
+        else if (typeof parameters?.minInclusive === "bigint") {
+            minInclusive = Maybe.of($literalFactory.bigint(parameters?.minInclusive));
+        }
+        else if (typeof parameters?.minInclusive === "boolean") {
+            minInclusive = Maybe.of($literalFactory.boolean(parameters?.minInclusive));
+        }
+        else if (typeof parameters?.minInclusive === "object" &&
+            parameters?.minInclusive instanceof Date) {
+            minInclusive = Maybe.of($literalFactory.date(parameters?.minInclusive));
+        }
+        else if (typeof parameters?.minInclusive === "number") {
+            minInclusive = Maybe.of($literalFactory.number(parameters?.minInclusive));
+        }
+        else if (typeof parameters?.minInclusive === "string") {
+            minInclusive = Maybe.of($literalFactory.string(parameters?.minInclusive));
+        }
+        else if (typeof parameters?.minInclusive === "object") {
+            minInclusive = Maybe.of(parameters?.minInclusive);
+        }
+        else if (parameters?.minInclusive === undefined) {
+            minInclusive = Maybe.empty();
+        }
+        else {
+            minInclusive = parameters?.minInclusive;
+        }
+        let minLength;
+        if (Maybe.isMaybe(parameters?.minLength)) {
+            minLength = parameters?.minLength;
+        }
+        else if (typeof parameters?.minLength === "number") {
+            minLength = Maybe.of(parameters?.minLength);
+        }
+        else if (parameters?.minLength === undefined) {
+            minLength = Maybe.empty();
+        }
+        else {
+            minLength = parameters?.minLength;
+        }
+        let nodeKind;
+        if (Maybe.isMaybe(parameters?.nodeKind)) {
+            nodeKind = parameters?.nodeKind;
+        }
+        else if (typeof parameters?.nodeKind === "object") {
+            nodeKind = Maybe.of(parameters?.nodeKind);
+        }
+        else if (typeof parameters?.nodeKind === "string") {
+            nodeKind = Maybe.of(dataFactory.namedNode(parameters?.nodeKind));
+        }
+        else if (parameters?.nodeKind === undefined) {
+            nodeKind = Maybe.empty();
+        }
+        else {
+            nodeKind = parameters?.nodeKind;
+        }
+        let nodes;
+        if (parameters?.nodes === undefined) {
+            nodes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.nodes)) {
+            nodes = parameters?.nodes;
+        }
+        else if ($isReadonlyStringArray(parameters?.nodes)) {
+            nodes = parameters?.nodes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            nodes = parameters?.nodes;
+        }
+        let not;
+        if (parameters?.not === undefined) {
+            not = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.not)) {
+            not = parameters?.not;
+        }
+        else if ($isReadonlyStringArray(parameters?.not)) {
+            not = parameters?.not.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            not = parameters?.not;
+        }
+        let or;
+        if (Maybe.isMaybe(parameters?.or)) {
+            or = parameters?.or;
+        }
+        else if ($isReadonlyObjectArray(parameters?.or)) {
+            or = Maybe.of(parameters?.or);
+        }
+        else if ($isReadonlyStringArray(parameters?.or)) {
+            or = Maybe.of(parameters?.or.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters?.or === undefined) {
+            or = Maybe.empty();
+        }
+        else {
+            or = parameters?.or;
+        }
+        let patterns;
+        if (parameters?.patterns === undefined) {
+            patterns = [];
+        }
+        else if (typeof parameters?.patterns === "object") {
+            patterns = parameters?.patterns;
+        }
+        else {
+            patterns = parameters?.patterns;
+        }
+        let properties;
+        if (parameters?.properties === undefined) {
+            properties = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.properties)) {
+            properties = parameters?.properties;
+        }
+        else if ($isReadonlyStringArray(parameters?.properties)) {
+            properties = parameters?.properties.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            properties = parameters?.properties;
+        }
+        let subClassOf;
+        if (parameters?.subClassOf === undefined) {
+            subClassOf = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.subClassOf)) {
+            subClassOf = parameters?.subClassOf;
+        }
+        else if ($isReadonlyStringArray(parameters?.subClassOf)) {
+            subClassOf = parameters?.subClassOf.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            subClassOf = parameters?.subClassOf;
+        }
+        let types;
+        if (parameters?.types === undefined) {
+            types = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.types)) {
+            types = parameters?.types;
+        }
+        else if ($isReadonlyStringArray(parameters?.types)) {
+            types = parameters?.types.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            types = parameters?.types;
+        }
+        let xone;
+        if (Maybe.isMaybe(parameters?.xone)) {
+            xone = parameters?.xone;
+        }
+        else if ($isReadonlyObjectArray(parameters?.xone)) {
+            xone = Maybe.of(parameters?.xone);
+        }
+        else if ($isReadonlyStringArray(parameters?.xone)) {
+            xone = Maybe.of(parameters?.xone.map((item) => dataFactory.namedNode(item)));
+        }
+        else if (parameters?.xone === undefined) {
+            xone = Maybe.empty();
+        }
+        else {
+            xone = parameters?.xone;
+        }
+        return {
+            $identifier,
+            $type,
+            and,
+            classes,
+            closed,
+            comment,
+            datatype,
+            deactivated,
+            flags,
+            hasValues,
+            ignoredProperties,
+            in_,
+            isDefinedBy,
+            label,
+            languageIn,
+            maxCount,
+            maxExclusive,
+            maxInclusive,
+            maxLength,
+            minCount,
+            minExclusive,
+            minInclusive,
+            minLength,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            patterns,
+            properties,
+            subClassOf,
+            types,
+            xone,
+        };
     }
-    Ontology.$toRdfResource = $toRdfResource;
-})(Ontology || (Ontology = {}));
-export var NodeShape;
-(function (NodeShape) {
+    NodeShape.$create = $create;
     let $Identifier;
     (function ($Identifier) {
         $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
@@ -1829,7 +3097,7 @@ export var NodeShape;
             return false;
         }
         if (filter.and !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.and, value.and)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
             return false;
         }
         if (filter.classes !== undefined &&
@@ -1840,8 +3108,8 @@ export var NodeShape;
             !$filterMaybe($filterBoolean)(filter.closed, value.closed)) {
             return false;
         }
-        if (filter.comments !== undefined &&
-            !$filterArray($filterString)(filter.comments, value.comments)) {
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
             return false;
         }
         if (filter.datatype !== undefined &&
@@ -1872,8 +3140,8 @@ export var NodeShape;
             !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
             return false;
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
             return false;
         }
         if (filter.languageIn !== undefined &&
@@ -1925,7 +3193,7 @@ export var NodeShape;
             return false;
         }
         if (filter.or !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
             return false;
         }
         if (filter.patterns !== undefined &&
@@ -1936,8 +3204,16 @@ export var NodeShape;
             !$filterArray($filterIdentifier)(filter.properties, value.properties)) {
             return false;
         }
+        if (filter.subClassOf !== undefined &&
+            !$filterArray($filterIri)(filter.subClassOf, value.subClassOf)) {
+            return false;
+        }
+        if (filter.types !== undefined &&
+            !$filterArray($filterIri)(filter.types, value.types)) {
+            return false;
+        }
         if (filter.xone !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            !$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
             return false;
         }
         return true;
@@ -2008,12 +3284,13 @@ export var NodeShape;
                 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,
-            })),
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.and.path,
+                    value: Maybe.empty(),
+                })),
         }).chain((and) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
@@ -2042,17 +3319,18 @@ export var NodeShape;
         }).chain((closed) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: NodeShape.$schema.properties.comments,
+            propertySchema: NodeShape.$schema.properties.comment,
             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.comments.path,
-                value: valuesArray,
-            })),
-        }).chain((comments) => $shaclPropertyFromRdf({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.comment.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((comment) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema.properties.datatype,
@@ -2196,18 +3474,19 @@ export var NodeShape;
         }).chain((isDefinedBy) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: NodeShape.$schema.properties.labels,
+            propertySchema: NodeShape.$schema.properties.label,
             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({
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema
+                        .properties.label.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((label) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema.properties.languageIn,
@@ -2449,16 +3728,18 @@ export var NodeShape;
                 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,
-            })),
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .or
+                        .path,
+                    value: Maybe.empty(),
+                })),
         }).chain((or) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
@@ -2497,6 +3778,42 @@ export var NodeShape;
                 value: valuesArray,
             })),
         }).chain((properties) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .subClassOf,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: NodeShape
+                    .$schema
+                    .properties
+                    .subClassOf
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((subClassOf) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .types,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: NodeShape
+                    .$schema
+                    .properties
+                    .types
+                    .path,
+                value: valuesArray,
+            })),
+        }).chain((types) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema
@@ -2516,23 +3833,25 @@ export var NodeShape;
                 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((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .xone
+                        .path,
+                    value: Maybe.empty(),
+                })),
         }).map((xone) => ({
             $identifier,
             $type,
             and,
             classes,
             closed,
-            comments,
+            comment,
             datatype,
             deactivated,
             flags,
@@ -2540,7 +3859,7 @@ export var NodeShape;
             ignoredProperties,
             in_,
             isDefinedBy,
-            labels,
+            label,
             languageIn,
             maxCount,
             maxExclusive,
@@ -2556,8 +3875,10 @@ export var NodeShape;
             or,
             patterns,
             properties,
+            subClassOf,
+            types,
             xone,
-        }))))))))))))))))))))))))))))))));
+        }))))))))))))))))))))))))))))))))));
     };
     NodeShape.$schema = {
         properties: {
@@ -2575,7 +3896,7 @@ export var NodeShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -2599,10 +3920,10 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
             },
-            comments: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
@@ -2669,10 +3990,10 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
             },
-            labels: {
+            label: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
@@ -2789,7 +4110,7 @@ export var NodeShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -2813,10 +4134,26 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
             },
-            xone: {
+            subClassOf: {
                 kind: "Shacl",
                 type: () => ({
                     kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: $RdfVocabularies.rdfs.subClassOf,
+            },
+            types: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: $RdfVocabularies.rdf.type,
+            },
+            xone: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -2833,9 +4170,9 @@ export var NodeShape;
         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#and"), _nodeShape.and.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), _nodeShape.and.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -2861,7 +4198,9 @@ export var NodeShape;
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
-        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/2000/01/rdf-schema#comment"), _nodeShape.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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()
@@ -2915,7 +4254,9 @@ export var NodeShape;
                 : $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/2000/01/rdf-schema#label"), _nodeShape.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), 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) => {
@@ -2965,9 +4306,9 @@ export var NodeShape;
         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) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -2989,9 +4330,11 @@ export var NodeShape;
         ]), 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) => {
+        resource.add($RdfVocabularies.rdfs.subClassOf, _nodeShape.subClassOf.flatMap((item) => [item]), options?.graph);
+        resource.add($RdfVocabularies.rdf.type, _nodeShape.types.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), _nodeShape.xone.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -3017,15 +4360,6 @@ export var NodeShape;
 })(NodeShape || (NodeShape = {}));
 export var Shape;
 (function (Shape) {
-    Shape.$toRdfResource = (value, options) => {
-        if (NodeShape.isNodeShape(value)) {
-            return NodeShape.$toRdfResource(value, options);
-        }
-        if (PropertyShape.isPropertyShape(value)) {
-            return PropertyShape.$toRdfResource(value, options);
-        }
-        throw new Error("unrecognized type");
-    };
     Shape.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
@@ -3092,7 +4426,7 @@ export var Shape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3108,10 +4442,10 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
             },
-            comments: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
@@ -3167,10 +4501,10 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
             },
-            labels: {
+            label: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
@@ -3287,7 +4621,7 @@ export var Shape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3306,7 +4640,7 @@ export var Shape;
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3316,6 +4650,15 @@ export var Shape;
             },
         },
     };
+    Shape.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
+        }
+        throw new Error("unrecognized type");
+    };
     Shape.$toRdfResourceValues = ((value, _options) => {
         if (NodeShape.isNodeShape(value)) {
             return [
@@ -3342,21 +4685,6 @@ export var Shape;
 })(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 (PropertyGroup.isPropertyGroup(value)) {
-            return PropertyGroup.$toRdfResource(value, options);
-        }
-        if (PropertyShape.isPropertyShape(value)) {
-            return PropertyShape.$toRdfResource(value, options);
-        }
-        throw new Error("unrecognized type");
-    };
     $Object.$filter = (filter, value) => {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
@@ -3463,16 +4791,39 @@ export var $Object;
             },
         },
         properties: {
-            labels: {
+            comment: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            label: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
             },
         },
     };
+    $Object.$toRdfResource = (value, options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toRdfResource(value, options);
+        }
+        if (Ontology.isOntology(value)) {
+            return Ontology.$toRdfResource(value, options);
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return PropertyGroup.$toRdfResource(value, options);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toRdfResource(value, options);
+        }
+        throw new Error("unrecognized type");
+    };
     $Object.$toRdfResourceValues = ((value, _options) => {
         if (NodeShape.isNodeShape(value)) {
             return [
@@ -3735,7 +5086,7 @@ export class $RdfjsDatasetObjectSet {
             },
         ], query);
     }
-    $objectsSync(objectType, query) {
+    $objectsSync(namedObjectType, query) {
         const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {
@@ -3759,11 +5110,11 @@ export class $RdfjsDatasetObjectSet {
             }));
             sortResources = false;
         }
-        else if (objectType.$fromRdfTypes.length > 0) {
+        else if (namedObjectType.$fromRdfTypes.length > 0) {
             const identifierSet = new $IdentifierSet();
             resources = [];
             sortResources = true;
-            for (const fromRdfType of objectType.$fromRdfTypes) {
+            for (const fromRdfType of namedObjectType.$fromRdfTypes) {
                 for (const resource of resourceSet.instancesOf(fromRdfType, {
                     graph,
                 })) {
@@ -3795,7 +5146,7 @@ export class $RdfjsDatasetObjectSet {
                 identifierSet.add(quad.subject);
                 const resource = resourceSet.resource(quad.subject);
                 // Eagerly eliminate the majority of resources that won't match the object type
-                objectType
+                namedObjectType
                     .$fromRdfResource(resource, fromRdfResourceOptions)
                     .ifRight((object) => {
                     resources.push({ object, resource });
@@ -3810,13 +5161,13 @@ export class $RdfjsDatasetObjectSet {
         const objects = [];
         for (let { object, resource } of resources) {
             if (!object) {
-                const objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
+                const objectEither = namedObjectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 if (objectEither.isLeft()) {
                     return objectEither;
                 }
                 object = objectEither.unsafeCoerce();
             }
-            if (query?.filter && !objectType.$filter(query.filter, object)) {
+            if (query?.filter && !namedObjectType.$filter(query.filter, object)) {
                 continue;
             }
             if (objectI++ >= offset) {
@@ -3828,7 +5179,7 @@ export class $RdfjsDatasetObjectSet {
         }
         return Right(objects);
     }
-    $objectUnionsSync(objectTypes, query) {
+    $objectUnionsSync(namedObjectTypes, query) {
         const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {
@@ -3852,18 +5203,18 @@ export class $RdfjsDatasetObjectSet {
             }));
             sortResources = false;
         }
-        else if (objectTypes.every((objectType) => objectType.$fromRdfTypes.length > 0)) {
+        else if (namedObjectTypes.every((namedObjectType) => namedObjectType.$fromRdfTypes.length > 0)) {
             const identifierSet = new $IdentifierSet();
             resources = [];
             sortResources = true;
-            for (const objectType of objectTypes) {
-                for (const fromRdfType of objectType.$fromRdfTypes) {
+            for (const namedObjectType of namedObjectTypes) {
+                for (const fromRdfType of namedObjectType.$fromRdfTypes) {
                     for (const resource of resourceSet.instancesOf(fromRdfType, {
                         graph,
                     })) {
                         if (!identifierSet.has(resource.identifier)) {
                             identifierSet.add(resource.identifier);
-                            resources.push({ objectType, resource });
+                            resources.push({ namedObjectType, resource });
                         }
                     }
                 }
@@ -3890,11 +5241,11 @@ export class $RdfjsDatasetObjectSet {
                 identifierSet.add(quad.subject);
                 // Eagerly eliminate the majority of resources that won't match the object types
                 const resource = resourceSet.resource(quad.subject);
-                for (const objectType of objectTypes) {
-                    if (objectType
+                for (const namedObjectType of namedObjectTypes) {
+                    if (namedObjectType
                         .$fromRdfResource(resource, fromRdfResourceOptions)
                         .ifRight((object) => {
-                        resources.push({ object, objectType, resource });
+                        resources.push({ object, namedObjectType, resource });
                     })
                         .isRight()) {
                         break;
@@ -3908,18 +5259,18 @@ export class $RdfjsDatasetObjectSet {
         }
         let objectI = 0;
         const objects = [];
-        for (let { object, objectType, resource } of resources) {
+        for (let { object, namedObjectType, resource } of resources) {
             if (!object) {
                 let objectEither;
-                if (objectType) {
-                    objectEither = objectType.$fromRdfResource(resource, fromRdfResourceOptions);
+                if (namedObjectType) {
+                    objectEither = namedObjectType.$fromRdfResource(resource, fromRdfResourceOptions);
                 }
                 else {
                     objectEither = Left(new Error("no object types"));
-                    for (const tryObjectType of objectTypes) {
+                    for (const tryObjectType of namedObjectTypes) {
                         objectEither = tryObjectType.$fromRdfResource(resource, fromRdfResourceOptions);
                         if (objectEither.isRight()) {
-                            objectType = tryObjectType;
+                            namedObjectType = tryObjectType;
                             break;
                         }
                     }
@@ -3929,10 +5280,10 @@ export class $RdfjsDatasetObjectSet {
                 }
                 object = objectEither.unsafeCoerce();
             }
-            if (!objectType) {
-                throw new Error("objectType should be set here");
+            if (!namedObjectType) {
+                throw new Error("namedObjectType should be set here");
             }
-            if (query?.filter && !objectType.$filter(query.filter, object)) {
+            if (query?.filter && !namedObjectType.$filter(query.filter, object)) {
                 continue;
             }
             if (objectI++ >= offset) {