@shaclmate/compiler 4.0.13 → 4.0.15

package/dist/input/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,302 +234,936 @@ function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }
 }
 export var PropertyShape;
 (function (PropertyShape) {
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = PropertyShape.$Identifier || (PropertyShape.$Identifier = {}));
-    function $filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier)) {
-            return false;
+    function $create(parameters) {
+        let $identifier;
+        if (typeof parameters.$identifier === "object") {
+            $identifier = parameters.$identifier;
         }
-        if (filter.and !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.and, value.and)) {
-            return false;
+        else if (typeof parameters.$identifier === "string") {
+            $identifier = dataFactory.namedNode(parameters.$identifier);
         }
-        if (filter.classes !== undefined &&
-            !$filterArray($filterIri)(filter.classes, value.classes)) {
-            return false;
+        else if (parameters.$identifier === undefined) {
+            $identifier = dataFactory.blankNode();
         }
-        if (filter.comments !== undefined &&
-            !$filterArray($filterString)(filter.comments, value.comments)) {
-            return false;
+        else {
+            $identifier = parameters.$identifier;
         }
-        if (filter.datatype !== undefined &&
-            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
-            return false;
+        const $type = "PropertyShape";
+        let and;
+        if (Maybe.isMaybe(parameters.and)) {
+            and = parameters.and;
         }
-        if (filter.deactivated !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
-            return false;
+        else if ($isReadonlyObjectArray(parameters.and)) {
+            and = Maybe.of(parameters.and);
         }
-        if (filter.defaultValue !== undefined &&
-            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
-            return false;
+        else if ($isReadonlyStringArray(parameters.and)) {
+            and = Maybe.of(parameters.and.map((item) => dataFactory.namedNode(item)));
         }
-        if (filter.descriptions !== undefined &&
-            !$filterArray($filterString)(filter.descriptions, value.descriptions)) {
-            return false;
+        else if (parameters.and === undefined) {
+            and = Maybe.empty();
         }
-        if (filter.flags !== undefined &&
-            !$filterArray($filterString)(filter.flags, value.flags)) {
-            return false;
+        else {
+            and = parameters.and;
         }
-        if (filter.groups !== undefined &&
-            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
-            return false;
+        let classes;
+        if (parameters.classes === undefined) {
+            classes = [];
         }
-        if (filter.hasValues !== undefined &&
-            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
-            return false;
+        else if ($isReadonlyObjectArray(parameters.classes)) {
+            classes = parameters.classes;
         }
-        if (filter.in_ !== undefined &&
-            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
-            return false;
+        else if ($isReadonlyStringArray(parameters.classes)) {
+            classes = parameters.classes.map((item) => dataFactory.namedNode(item));
         }
-        if (filter.isDefinedBy !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
-            return false;
+        else {
+            classes = parameters.classes;
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
-            return false;
+        let comment;
+        if (Maybe.isMaybe(parameters.comment)) {
+            comment = parameters.comment;
         }
-        if (filter.languageIn !== undefined &&
-            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
-            return false;
+        else if (typeof parameters.comment === "string") {
+            comment = Maybe.of(parameters.comment);
         }
-        if (filter.maxCount !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
-            return false;
+        else if (parameters.comment === undefined) {
+            comment = Maybe.empty();
         }
-        if (filter.maxExclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
-            return false;
+        else {
+            comment = parameters.comment;
         }
-        if (filter.maxInclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
-            return false;
+        let datatype;
+        if (Maybe.isMaybe(parameters.datatype)) {
+            datatype = parameters.datatype;
         }
-        if (filter.maxLength !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
-            return false;
+        else if (typeof parameters.datatype === "object") {
+            datatype = Maybe.of(parameters.datatype);
         }
-        if (filter.minCount !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
-            return false;
+        else if (typeof parameters.datatype === "string") {
+            datatype = Maybe.of(dataFactory.namedNode(parameters.datatype));
         }
-        if (filter.minExclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
-            return false;
+        else if (parameters.datatype === undefined) {
+            datatype = Maybe.empty();
         }
-        if (filter.minInclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
-            return false;
+        else {
+            datatype = parameters.datatype;
         }
-        if (filter.minLength !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
-            return false;
+        let deactivated;
+        if (Maybe.isMaybe(parameters.deactivated)) {
+            deactivated = parameters.deactivated;
         }
-        if (filter.mutable !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
-            return false;
+        else if (typeof parameters.deactivated === "boolean") {
+            deactivated = Maybe.of(parameters.deactivated);
         }
-        if (filter.name !== undefined &&
-            !$filterMaybe($filterString)(filter.name, value.name)) {
-            return false;
+        else if (parameters.deactivated === undefined) {
+            deactivated = Maybe.empty();
         }
-        if (filter.names !== undefined &&
-            !$filterArray($filterString)(filter.names, value.names)) {
-            return false;
+        else {
+            deactivated = parameters.deactivated;
         }
-        if (filter.nodeKind !== undefined &&
-            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
-            return false;
+        let defaultValue;
+        if (Maybe.isMaybe(parameters.defaultValue)) {
+            defaultValue = parameters.defaultValue;
         }
-        if (filter.nodes !== undefined &&
-            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
-            return false;
+        else if (typeof parameters.defaultValue === "bigint") {
+            defaultValue = Maybe.of($literalFactory.bigint(parameters.defaultValue));
         }
-        if (filter.not !== undefined &&
-            !$filterArray($filterIdentifier)(filter.not, value.not)) {
-            return false;
+        else if (typeof parameters.defaultValue === "boolean") {
+            defaultValue = Maybe.of($literalFactory.boolean(parameters.defaultValue));
         }
-        if (filter.or !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
-            return false;
+        else if (typeof parameters.defaultValue === "object" &&
+            parameters.defaultValue instanceof Date) {
+            defaultValue = Maybe.of($literalFactory.date(parameters.defaultValue));
         }
-        if (filter.order !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
-            return false;
+        else if (typeof parameters.defaultValue === "number") {
+            defaultValue = Maybe.of($literalFactory.number(parameters.defaultValue));
         }
-        if (filter.path !== undefined &&
-            !$PropertyPath.$filter(filter.path, value.path)) {
-            return false;
+        else if (typeof parameters.defaultValue === "string") {
+            defaultValue = Maybe.of($literalFactory.string(parameters.defaultValue));
         }
-        if (filter.patterns !== undefined &&
-            !$filterArray($filterString)(filter.patterns, value.patterns)) {
-            return false;
+        else if (typeof parameters.defaultValue === "object") {
+            defaultValue = Maybe.of(parameters.defaultValue);
         }
-        if (filter.resolve !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.resolve, value.resolve)) {
-            return false;
+        else if (parameters.defaultValue === undefined) {
+            defaultValue = Maybe.empty();
         }
-        if (filter.uniqueLang !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
-            return false;
+        else {
+            defaultValue = parameters.defaultValue;
         }
-        if (filter.visibility !== undefined &&
-            !$filterMaybe($filterIri)(filter.visibility, value.visibility)) {
-            return false;
+        let description;
+        if (Maybe.isMaybe(parameters.description)) {
+            description = parameters.description;
         }
-        if (filter.xone !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.xone, value.xone)) {
-            return false;
+        else if (typeof parameters.description === "string") {
+            description = Maybe.of(parameters.description);
         }
-        return true;
-    }
-    PropertyShape.$filter = $filter;
-    PropertyShape.$fromRdfResource = (resource, options) => {
-        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
-        if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        else if (parameters.description === undefined) {
+            description = Maybe.empty();
         }
-        return PropertyShape.$propertiesFromRdfResource(resource, {
-            context,
-            graph,
-            ignoreRdfType,
-            objectSet,
-            preferredLanguages,
-        });
-    };
-    PropertyShape.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => PropertyShape.$fromRdfResource(resource, options))));
-    PropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
-    function isPropertyShape(object) {
-        switch (object.$type) {
-            case "PropertyShape":
-                return true;
-            default:
-                return false;
+        else {
+            description = parameters.description;
         }
-    }
-    PropertyShape.isPropertyShape = isPropertyShape;
-    PropertyShape.$propertiesFromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#PropertyShape":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(PropertyShape.$fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
-            })
-            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues())
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .chain((values) => values.head())
-            .chain(($identifier) => Right("PropertyShape").chain(($type) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.and,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                focusResource: $resource,
-                propertyPath: PropertyShape.$schema.properties.and.path,
-                values: valueList.toArray(),
-            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: PropertyShape.$schema.properties.and.path,
-                value: valuesArray,
-            })),
-        }).chain((and) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.classes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: PropertyShape.$schema.properties.classes.path,
-                value: valuesArray,
-            })),
-        }).chain((classes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.comments,
-            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({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.datatype,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.$schema.properties.datatype
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((datatype) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.deactivated,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.$schema.properties.deactivated
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((deactivated) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.defaultValue,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                switch (term.termType) {
-                    case "NamedNode":
-                    case "Literal":
-                        return Either.of(term);
-                    default:
-                        return Left(new Resource.MistypedTermValueError({
-                            actualValue: term,
-                            expectedValueType: "(NamedNode | Literal)",
-                            focusResource: $resource,
+        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 mutable;
+        if (Maybe.isMaybe(parameters.mutable)) {
+            mutable = parameters.mutable;
+        }
+        else if (typeof parameters.mutable === "boolean") {
+            mutable = Maybe.of(parameters.mutable);
+        }
+        else if (parameters.mutable === undefined) {
+            mutable = Maybe.empty();
+        }
+        else {
+            mutable = parameters.mutable;
+        }
+        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 resolve;
+        if (Maybe.isMaybe(parameters.resolve)) {
+            resolve = parameters.resolve;
+        }
+        else if (typeof parameters.resolve === "object") {
+            resolve = Maybe.of(parameters.resolve);
+        }
+        else if (typeof parameters.resolve === "string") {
+            resolve = Maybe.of(dataFactory.namedNode(parameters.resolve));
+        }
+        else if (parameters.resolve === undefined) {
+            resolve = Maybe.empty();
+        }
+        else {
+            resolve = parameters.resolve;
+        }
+        let shaclmateName;
+        if (Maybe.isMaybe(parameters.shaclmateName)) {
+            shaclmateName = parameters.shaclmateName;
+        }
+        else if (typeof parameters.shaclmateName === "string") {
+            shaclmateName = Maybe.of(parameters.shaclmateName);
+        }
+        else if (parameters.shaclmateName === undefined) {
+            shaclmateName = Maybe.empty();
+        }
+        else {
+            shaclmateName = parameters.shaclmateName;
+        }
+        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 visibility;
+        if (Maybe.isMaybe(parameters.visibility)) {
+            visibility = parameters.visibility;
+        }
+        else if (typeof parameters.visibility === "object") {
+            visibility = Maybe.of(parameters.visibility);
+        }
+        else if (typeof parameters.visibility === "string") {
+            visibility = Maybe.of(dataFactory.namedNode(parameters.visibility));
+        }
+        else if (parameters.visibility === undefined) {
+            visibility = Maybe.empty();
+        }
+        else {
+            visibility = parameters.visibility;
+        }
+        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,
+            mutable,
+            name,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            order,
+            path,
+            patterns,
+            resolve,
+            shaclmateName,
+            uniqueLang,
+            visibility,
+            xone,
+        };
+    }
+    PropertyShape.$create = $create;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = PropertyShape.$Identifier || (PropertyShape.$Identifier = {}));
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.and !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
+            return false;
+        }
+        if (filter.classes !== undefined &&
+            !$filterArray($filterIri)(filter.classes, value.classes)) {
+            return false;
+        }
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
+        }
+        if (filter.datatype !== undefined &&
+            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
+            return false;
+        }
+        if (filter.deactivated !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
+            return false;
+        }
+        if (filter.defaultValue !== undefined &&
+            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
+            return false;
+        }
+        if (filter.description !== undefined &&
+            !$filterMaybe($filterString)(filter.description, value.description)) {
+            return false;
+        }
+        if (filter.flags !== undefined &&
+            !$filterArray($filterString)(filter.flags, value.flags)) {
+            return false;
+        }
+        if (filter.groups !== undefined &&
+            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
+            return false;
+        }
+        if (filter.hasValues !== undefined &&
+            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
+            return false;
+        }
+        if (filter.in_ !== undefined &&
+            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
+            return false;
+        }
+        if (filter.isDefinedBy !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
+            return false;
+        }
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
+            return false;
+        }
+        if (filter.languageIn !== undefined &&
+            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
+            return false;
+        }
+        if (filter.maxCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
+            return false;
+        }
+        if (filter.maxExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
+            return false;
+        }
+        if (filter.maxInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
+            return false;
+        }
+        if (filter.maxLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
+            return false;
+        }
+        if (filter.minCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
+            return false;
+        }
+        if (filter.minExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
+            return false;
+        }
+        if (filter.minInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
+            return false;
+        }
+        if (filter.minLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
+            return false;
+        }
+        if (filter.mutable !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
+            return false;
+        }
+        if (filter.name !== undefined &&
+            !$filterMaybe($filterString)(filter.name, value.name)) {
+            return false;
+        }
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+            return false;
+        }
+        if (filter.nodes !== undefined &&
+            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
+            return false;
+        }
+        if (filter.not !== undefined &&
+            !$filterArray($filterIdentifier)(filter.not, value.not)) {
+            return false;
+        }
+        if (filter.or !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
+            return false;
+        }
+        if (filter.order !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
+            return false;
+        }
+        if (filter.path !== undefined &&
+            !$PropertyPath.$filter(filter.path, value.path)) {
+            return false;
+        }
+        if (filter.patterns !== undefined &&
+            !$filterArray($filterString)(filter.patterns, value.patterns)) {
+            return false;
+        }
+        if (filter.resolve !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.resolve, value.resolve)) {
+            return false;
+        }
+        if (filter.shaclmateName !== undefined &&
+            !$filterMaybe($filterString)(filter.shaclmateName, value.shaclmateName)) {
+            return false;
+        }
+        if (filter.uniqueLang !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
+            return false;
+        }
+        if (filter.visibility !== undefined &&
+            !$filterMaybe($filterIri)(filter.visibility, value.visibility)) {
+            return false;
+        }
+        if (filter.xone !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            return false;
+        }
+        return true;
+    }
+    PropertyShape.$filter = $filter;
+    PropertyShape.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        }
+        return PropertyShape.$propertiesFromRdfResource(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            objectSet,
+            preferredLanguages,
+        });
+    };
+    PropertyShape.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyShape.$fromRdfResource(resource, options))));
+    PropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
+    function isPropertyShape(object) {
+        switch (object.$type) {
+            case "PropertyShape":
+                return true;
+            default:
+                return false;
+        }
+    }
+    PropertyShape.isPropertyShape = isPropertyShape;
+    PropertyShape.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => {
+                // Check the expected type and its known subtypes
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/ns/shacl#PropertyShape":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(PropertyShape.$fromRdfType, {
+                    graph: _$options.graph,
+                })) {
+                    return Right(true);
+                }
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues())
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("PropertyShape").chain(($type) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.and,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
+                .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.and.path,
+                values: valueList.toArray(),
+            })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+                .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+                .map((values) => values.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,
+            propertySchema: PropertyShape.$schema.properties.classes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: PropertyShape.$schema.properties.classes.path,
+                value: valuesArray,
+            })),
+        }).chain((classes) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.comment,
+            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.comment.path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((comment) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.datatype,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.datatype
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((datatype) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.deactivated,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toBoolean()))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties.deactivated
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((deactivated) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.defaultValue,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                switch (term.termType) {
+                    case "NamedNode":
+                    case "Literal":
+                        return Either.of(term);
+                    default:
+                        return Left(new Resource.MistypedTermValueError({
+                            actualValue: term,
+                            expectedValueType: "(NamedNode | Literal)",
+                            focusResource: $resource,
                             propertyPath: PropertyShape.$schema.properties
                                 .defaultValue.path,
                         }));
@@ -531,18 +1180,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,
@@ -654,18 +1304,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,
@@ -871,25 +1522,6 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((name) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema
-                .properties
-                .names,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: PropertyShape
-                    .$schema
-                    .properties
-                    .names
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((names) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema
@@ -972,16 +1604,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,
@@ -1061,6 +1695,27 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((resolve) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .shaclmateName,
+            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
+                        .shaclmateName
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((shaclmateName) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema
@@ -1124,32 +1779,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,
@@ -1161,7 +1818,6 @@ export var PropertyShape;
             minLength,
             mutable,
             name,
-            names,
             nodeKind,
             nodes,
             not,
@@ -1170,6 +1826,7 @@ export var PropertyShape;
             path,
             patterns,
             resolve,
+            shaclmateName,
             uniqueLang,
             visibility,
             xone,
@@ -1191,7 +1848,7 @@ export var PropertyShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1207,10 +1864,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"),
@@ -1239,10 +1896,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"),
@@ -1290,10 +1947,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"),
@@ -1387,14 +2044,6 @@ export var PropertyShape;
                     kind: "Maybe",
                     item: () => ({ kind: "String" }),
                 }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
-            },
-            names: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
             },
             nodeKind: {
@@ -1434,7 +2083,7 @@ export var PropertyShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1471,6 +2120,14 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#resolve"),
             },
+            shaclmateName: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+            },
             uniqueLang: {
                 kind: "Shacl",
                 type: () => ({
@@ -1497,7 +2154,7 @@ export var PropertyShape;
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1514,9 +2171,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;
                     }
@@ -1537,7 +2194,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()
@@ -1545,9 +2204,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);
@@ -1574,7 +2233,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) => {
@@ -1626,16 +2287,15 @@ export var PropertyShape;
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), _propertyShape.name
+        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#name"), _propertyShape.names.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _propertyShape.nodeKind.toList(), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _propertyShape.nodes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _propertyShape.not.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        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;
                     }
@@ -1668,15 +2328,18 @@ export var PropertyShape;
         ], options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), _propertyShape.patterns.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#resolve"), _propertyShape.resolve.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), _propertyShape.shaclmateName
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), _propertyShape.uniqueLang
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#visibility"), _propertyShape.visibility.toList(), 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;
                     }
@@ -1702,6 +2365,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
@@ -1712,12 +2419,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;
@@ -1779,32 +2486,396 @@ 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.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.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 }))))));
+    };
+    PropertyGroup.$schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "Discriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["PropertyGroup"],
+                }),
+            },
+            comment: {
+                kind: "Shacl",
+                type: () => ({
+                    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"),
+            },
+        },
+    };
+    function $toRdfResource(_propertyGroup, options) {
+        const resourceSet = options?.resourceSet ??
+            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+        const resource = resourceSet.resource(_propertyGroup.$identifier);
+        if (!options?.ignoreRdfType) {
+            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
+        }
+        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;
+        }
+        let tsFeatureExcludes;
+        if (parameters?.tsFeatureExcludes === undefined) {
+            tsFeatureExcludes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.tsFeatureExcludes)) {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes;
+        }
+        else if ($isReadonlyStringArray(parameters?.tsFeatureExcludes)) {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes;
+        }
+        let tsFeatureIncludes;
+        if (parameters?.tsFeatureIncludes === undefined) {
+            tsFeatureIncludes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.tsFeatureIncludes)) {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes;
+        }
+        else if ($isReadonlyStringArray(parameters?.tsFeatureIncludes)) {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes;
+        }
+        let tsImports;
+        if (parameters?.tsImports === undefined) {
+            tsImports = [];
+        }
+        else if (typeof parameters?.tsImports === "object") {
+            tsImports = parameters?.tsImports;
+        }
+        else {
+            tsImports = parameters?.tsImports;
+        }
+        let tsObjectDeclarationType;
+        if (Maybe.isMaybe(parameters?.tsObjectDeclarationType)) {
+            tsObjectDeclarationType = parameters?.tsObjectDeclarationType;
+        }
+        else if (typeof parameters?.tsObjectDeclarationType === "object") {
+            tsObjectDeclarationType = Maybe.of(parameters?.tsObjectDeclarationType);
+        }
+        else if (typeof parameters?.tsObjectDeclarationType === "string") {
+            tsObjectDeclarationType = Maybe.of(dataFactory.namedNode(parameters?.tsObjectDeclarationType));
+        }
+        else if (parameters?.tsObjectDeclarationType === undefined) {
+            tsObjectDeclarationType = Maybe.empty();
+        }
+        else {
+            tsObjectDeclarationType =
+                parameters?.tsObjectDeclarationType;
+        }
+        return {
+            $identifier,
+            $type,
+            comment,
+            label,
+            tsFeatureExcludes,
+            tsFeatureIncludes,
+            tsImports,
+            tsObjectDeclarationType,
+        };
+    }
+    Ontology.$create = $create;
+    let $Identifier;
+    (function ($Identifier) {
+        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = Ontology.$Identifier || (Ontology.$Identifier = {}));
+    function $filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier)) {
+            return false;
+        }
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
+        }
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
+            return false;
+        }
+        if (filter.tsFeatureExcludes !== undefined &&
+            !$filterArray($filterIri)(filter.tsFeatureExcludes, value.tsFeatureExcludes)) {
+            return false;
+        }
+        if (filter.tsFeatureIncludes !== undefined &&
+            !$filterArray($filterIri)(filter.tsFeatureIncludes, value.tsFeatureIncludes)) {
+            return false;
+        }
+        if (filter.tsImports !== undefined &&
+            !$filterArray($filterString)(filter.tsImports, value.tsImports)) {
+            return false;
+        }
+        if (filter.tsObjectDeclarationType !== undefined &&
+            !$filterMaybe($filterIri)(filter.tsObjectDeclarationType, value.tsObjectDeclarationType)) {
+            return false;
+        }
+        return true;
+    }
+    Ontology.$filter = $filter;
+    Ontology.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        }
+        return Ontology.$propertiesFromRdfResource(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            objectSet,
+            preferredLanguages,
+        });
+    };
+    Ontology.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Ontology.$fromRdfResource(resource, options))));
+    Ontology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    function isOntology(object) {
+        switch (object.$type) {
+            case "Ontology":
+                return true;
+            default:
+                return false;
+        }
+    }
+    Ontology.isOntology = isOntology;
+    Ontology.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => {
+                // Check the expected type and its known subtypes
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/2002/07/owl#Ontology":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(Ontology.$fromRdfType, {
+                    graph: _$options.graph,
+                })) {
+                    return Right(true);
+                }
+                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues())
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .chain((values) => values.head())
+            .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.comment,
+            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.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(),
+                })),
+        }).chain((label) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.tsFeatureExcludes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri([
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+            ])))
+                .map((values) => values.toArray())
+                .map((valuesArray) => Resource.Values.fromValue({
+                focusResource: $resource,
+                propertyPath: Ontology.$schema.properties.tsFeatureExcludes.path,
+                value: valuesArray,
+            })),
+        }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.tsFeatureIncludes,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri([
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+            ])))
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
                 focusResource: $resource,
-                propertyPath: PropertyGroup.$schema.properties.comments.path,
+                propertyPath: Ontology.$schema.properties.tsFeatureIncludes
+                    .path,
                 value: valuesArray,
             })),
-        }).chain((comments) => $shaclPropertyFromRdf({
+        }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyGroup.$schema.properties.labels,
+            propertySchema: Ontology.$schema.properties.tsImports,
             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,
+                propertyPath: Ontology.$schema.properties.tsImports.path,
                 value: valuesArray,
             })),
-        }).map((labels) => ({ $identifier, $type, comments, labels }))))));
+        }).chain((tsImports) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: Ontology.$schema.properties.tsObjectDeclarationType,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIri([
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"),
+                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface"),
+            ])))
+                .map((values) => values.length > 0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: Ontology.$schema.properties
+                        .tsObjectDeclarationType.path,
+                    value: Maybe.empty(),
+                })),
+        }).map((tsObjectDeclarationType) => ({
+            $identifier,
+            $type,
+            comment,
+            label,
+            tsFeatureExcludes,
+            tsFeatureIncludes,
+            tsImports,
+            tsObjectDeclarationType,
+        }))))))))));
     };
-    PropertyGroup.$schema = {
+    Ontology.$schema = {
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -1814,334 +2885,850 @@ export var PropertyGroup;
                 kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
-                    ownValues: ["PropertyGroup"],
+                    ownValues: ["Ontology"],
                 }),
             },
-            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"),
             },
+            tsFeatureExcludes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
+            },
+            tsFeatureIncludes: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
+            },
+            tsImports: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
+            },
+            tsObjectDeclarationType: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"),
+                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface"),
+                        ],
+                    }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
+            },
         },
     };
-    function $toRdfResource(_propertyGroup, options) {
+    function $toRdfResource(_ontology, options) {
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = resourceSet.resource(_propertyGroup.$identifier);
+        const resource = resourceSet.resource(_ontology.$identifier);
         if (!options?.ignoreRdfType) {
-            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
+            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#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);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), _ontology.tsFeatureExcludes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), _ontology.tsFeatureIncludes.flatMap((item) => [item]), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), _ontology.tsImports.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), _ontology.tsObjectDeclarationType.toList(), 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 abstract;
+        if (Maybe.isMaybe(parameters?.abstract)) {
+            abstract = parameters?.abstract;
+        }
+        else if (typeof parameters?.abstract === "boolean") {
+            abstract = Maybe.of(parameters?.abstract);
+        }
+        else if (parameters?.abstract === undefined) {
+            abstract = Maybe.empty();
+        }
+        else {
+            abstract = parameters?.abstract;
+        }
+        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 discriminantValue;
+        if (Maybe.isMaybe(parameters?.discriminantValue)) {
+            discriminantValue = parameters?.discriminantValue;
+        }
+        else if (typeof parameters?.discriminantValue === "string") {
+            discriminantValue = Maybe.of(parameters?.discriminantValue);
+        }
+        else if (parameters?.discriminantValue === undefined) {
+            discriminantValue = Maybe.empty();
+        }
+        else {
+            discriminantValue = parameters?.discriminantValue;
+        }
+        let extern;
+        if (Maybe.isMaybe(parameters?.extern)) {
+            extern = parameters?.extern;
+        }
+        else if (typeof parameters?.extern === "boolean") {
+            extern = Maybe.of(parameters?.extern);
+        }
+        else if (parameters?.extern === undefined) {
+            extern = Maybe.empty();
+        }
+        else {
+            extern = parameters?.extern;
+        }
+        let flags;
+        if (parameters?.flags === undefined) {
+            flags = [];
+        }
+        else if (typeof parameters?.flags === "object") {
+            flags = parameters?.flags;
+        }
+        else {
+            flags = parameters?.flags;
+        }
+        let fromRdfType;
+        if (Maybe.isMaybe(parameters?.fromRdfType)) {
+            fromRdfType = parameters?.fromRdfType;
+        }
+        else if (typeof parameters?.fromRdfType === "object") {
+            fromRdfType = Maybe.of(parameters?.fromRdfType);
+        }
+        else if (typeof parameters?.fromRdfType === "string") {
+            fromRdfType = Maybe.of(dataFactory.namedNode(parameters?.fromRdfType));
+        }
+        else if (parameters?.fromRdfType === undefined) {
+            fromRdfType = Maybe.empty();
+        }
+        else {
+            fromRdfType = parameters?.fromRdfType;
+        }
+        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 identifierMintingStrategy;
+        if (Maybe.isMaybe(parameters?.identifierMintingStrategy)) {
+            identifierMintingStrategy = parameters?.identifierMintingStrategy;
+        }
+        else if (typeof parameters?.identifierMintingStrategy === "object") {
+            identifierMintingStrategy = Maybe.of(parameters?.identifierMintingStrategy);
+        }
+        else if (typeof parameters?.identifierMintingStrategy === "string") {
+            identifierMintingStrategy = Maybe.of(dataFactory.namedNode(parameters?.identifierMintingStrategy));
+        }
+        else if (parameters?.identifierMintingStrategy === undefined) {
+            identifierMintingStrategy = Maybe.empty();
+        }
+        else {
+            identifierMintingStrategy =
+                parameters?.identifierMintingStrategy;
+        }
+        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)));
         }
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), _propertyGroup.comments.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _propertyGroup.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
-        return resource;
-    }
-    PropertyGroup.$toRdfResource = $toRdfResource;
-})(PropertyGroup || (PropertyGroup = {}));
-export var Ontology;
-(function (Ontology) {
-    let $Identifier;
-    (function ($Identifier) {
-        $Identifier.fromString = $identifierFromString; // biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-        $Identifier.toString = Resource.Identifier.toString;
-    })($Identifier = Ontology.$Identifier || (Ontology.$Identifier = {}));
-    function $filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier)) {
-            return false;
+        else if ($isReadonlyNumberArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.number(item)));
         }
-        if (filter.labels !== undefined &&
-            !$filterArray($filterString)(filter.labels, value.labels)) {
-            return false;
+        else if ($isReadonlyStringArray(parameters?.in_)) {
+            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.string(item)));
         }
-        if (filter.tsFeatureExcludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureExcludes, value.tsFeatureExcludes)) {
-            return false;
+        else if (parameters?.in_ === undefined) {
+            in_ = Maybe.empty();
         }
-        if (filter.tsFeatureIncludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureIncludes, value.tsFeatureIncludes)) {
-            return false;
+        else {
+            in_ = parameters?.in_;
         }
-        if (filter.tsImports !== undefined &&
-            !$filterArray($filterString)(filter.tsImports, value.tsImports)) {
-            return false;
+        let isDefinedBy;
+        if (Maybe.isMaybe(parameters?.isDefinedBy)) {
+            isDefinedBy = parameters?.isDefinedBy;
         }
-        if (filter.tsObjectDeclarationType !== undefined &&
-            !$filterMaybe($filterIri)(filter.tsObjectDeclarationType, value.tsObjectDeclarationType)) {
-            return false;
+        else if (typeof parameters?.isDefinedBy === "object") {
+            isDefinedBy = Maybe.of(parameters?.isDefinedBy);
         }
-        return true;
-    }
-    Ontology.$filter = $filter;
-    Ontology.$fromRdfResource = (resource, options) => {
-        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
-        if (!objectSet) {
-            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        else if (typeof parameters?.isDefinedBy === "string") {
+            isDefinedBy = Maybe.of(dataFactory.namedNode(parameters?.isDefinedBy));
         }
-        return Ontology.$propertiesFromRdfResource(resource, {
-            context,
-            graph,
-            ignoreRdfType,
-            objectSet,
-            preferredLanguages,
-        });
-    };
-    Ontology.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => Ontology.$fromRdfResource(resource, options))));
-    Ontology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
-    function isOntology(object) {
-        switch (object.$type) {
-            case "Ontology":
-                return true;
-            default:
-                return false;
+        else if (parameters?.isDefinedBy === undefined) {
+            isDefinedBy = Maybe.empty();
         }
-    }
-    Ontology.isOntology = isOntology;
-    Ontology.$propertiesFromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/2002/07/owl#Ontology":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(Ontology.$fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${Resource.Identifier.toString($resource.identifier)} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
-            })
-            : Right(true)).chain((_rdfTypeCheck) => Right(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues())
-            .chain((values) => values.chainMap((value) => value.toIdentifier()))
-            .chain((values) => values.head())
-            .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.$schema.properties.labels,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.$schema.properties.labels.path,
-                value: valuesArray,
-            })),
-        }).chain((labels) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.$schema.properties.tsFeatureExcludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.$schema.properties.tsFeatureExcludes.path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.$schema.properties.tsFeatureIncludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.$schema.properties.tsFeatureIncludes.path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.$schema.properties.tsImports,
-            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.tsImports.path,
-                value: valuesArray,
-            })),
-        }).chain((tsImports) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.$schema.properties.tsObjectDeclarationType,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface"),
-            ])))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.$schema.properties
-                        .tsObjectDeclarationType.path,
-                    value: Maybe.empty(),
-                })),
-        }).map((tsObjectDeclarationType) => ({
+        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 mutable;
+        if (Maybe.isMaybe(parameters?.mutable)) {
+            mutable = parameters?.mutable;
+        }
+        else if (typeof parameters?.mutable === "boolean") {
+            mutable = Maybe.of(parameters?.mutable);
+        }
+        else if (parameters?.mutable === undefined) {
+            mutable = Maybe.empty();
+        }
+        else {
+            mutable = parameters?.mutable;
+        }
+        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 rdfType;
+        if (Maybe.isMaybe(parameters?.rdfType)) {
+            rdfType = parameters?.rdfType;
+        }
+        else if (typeof parameters?.rdfType === "object") {
+            rdfType = Maybe.of(parameters?.rdfType);
+        }
+        else if (typeof parameters?.rdfType === "string") {
+            rdfType = Maybe.of(dataFactory.namedNode(parameters?.rdfType));
+        }
+        else if (parameters?.rdfType === undefined) {
+            rdfType = Maybe.empty();
+        }
+        else {
+            rdfType = parameters?.rdfType;
+        }
+        let shaclmateName;
+        if (Maybe.isMaybe(parameters?.shaclmateName)) {
+            shaclmateName = parameters?.shaclmateName;
+        }
+        else if (typeof parameters?.shaclmateName === "string") {
+            shaclmateName = Maybe.of(parameters?.shaclmateName);
+        }
+        else if (parameters?.shaclmateName === undefined) {
+            shaclmateName = Maybe.empty();
+        }
+        else {
+            shaclmateName = parameters?.shaclmateName;
+        }
+        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 toRdfTypes;
+        if (parameters?.toRdfTypes === undefined) {
+            toRdfTypes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.toRdfTypes)) {
+            toRdfTypes = parameters?.toRdfTypes;
+        }
+        else if ($isReadonlyStringArray(parameters?.toRdfTypes)) {
+            toRdfTypes = parameters?.toRdfTypes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            toRdfTypes = parameters?.toRdfTypes;
+        }
+        let tsFeatureExcludes;
+        if (parameters?.tsFeatureExcludes === undefined) {
+            tsFeatureExcludes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.tsFeatureExcludes)) {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes;
+        }
+        else if ($isReadonlyStringArray(parameters?.tsFeatureExcludes)) {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            tsFeatureExcludes = parameters?.tsFeatureExcludes;
+        }
+        let tsFeatureIncludes;
+        if (parameters?.tsFeatureIncludes === undefined) {
+            tsFeatureIncludes = [];
+        }
+        else if ($isReadonlyObjectArray(parameters?.tsFeatureIncludes)) {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes;
+        }
+        else if ($isReadonlyStringArray(parameters?.tsFeatureIncludes)) {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes.map((item) => dataFactory.namedNode(item));
+        }
+        else {
+            tsFeatureIncludes = parameters?.tsFeatureIncludes;
+        }
+        let tsImports;
+        if (parameters?.tsImports === undefined) {
+            tsImports = [];
+        }
+        else if (typeof parameters?.tsImports === "object") {
+            tsImports = parameters?.tsImports;
+        }
+        else {
+            tsImports = parameters?.tsImports;
+        }
+        let tsObjectDeclarationType;
+        if (Maybe.isMaybe(parameters?.tsObjectDeclarationType)) {
+            tsObjectDeclarationType = parameters?.tsObjectDeclarationType;
+        }
+        else if (typeof parameters?.tsObjectDeclarationType === "object") {
+            tsObjectDeclarationType = Maybe.of(parameters?.tsObjectDeclarationType);
+        }
+        else if (typeof parameters?.tsObjectDeclarationType === "string") {
+            tsObjectDeclarationType = Maybe.of(dataFactory.namedNode(parameters?.tsObjectDeclarationType));
+        }
+        else if (parameters?.tsObjectDeclarationType === undefined) {
+            tsObjectDeclarationType = Maybe.empty();
+        }
+        else {
+            tsObjectDeclarationType =
+                parameters?.tsObjectDeclarationType;
+        }
+        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,
-            labels,
+            abstract,
+            and,
+            classes,
+            closed,
+            comment,
+            datatype,
+            deactivated,
+            discriminantValue,
+            extern,
+            flags,
+            fromRdfType,
+            hasValues,
+            identifierMintingStrategy,
+            ignoredProperties,
+            in_,
+            isDefinedBy,
+            label,
+            languageIn,
+            maxCount,
+            maxExclusive,
+            maxInclusive,
+            maxLength,
+            minCount,
+            minExclusive,
+            minInclusive,
+            minLength,
+            mutable,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            patterns,
+            properties,
+            rdfType,
+            shaclmateName,
+            subClassOf,
+            toRdfTypes,
             tsFeatureExcludes,
             tsFeatureIncludes,
             tsImports,
             tsObjectDeclarationType,
-        })))))))));
-    };
-    Ontology.$schema = {
-        properties: {
-            $identifier: {
-                kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["Ontology"],
-                }),
-            },
-            labels: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
-            },
-            tsFeatureExcludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
-            },
-            tsFeatureIncludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
-            },
-            tsImports: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
-            },
-            tsObjectDeclarationType: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
-            },
-        },
-    };
-    function $toRdfResource(_ontology, options) {
-        const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
-        const resource = resourceSet.resource(_ontology.$identifier);
-        if (!options?.ignoreRdfType) {
-            resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
-        }
-        resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), _ontology.labels.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), _ontology.tsFeatureExcludes.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), _ontology.tsFeatureIncludes.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), _ontology.tsImports.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), _ontology.tsObjectDeclarationType.toList(), options?.graph);
-        return resource;
+            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
@@ -2157,7 +3744,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 &&
@@ -2168,8 +3755,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 &&
@@ -2216,8 +3803,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 &&
@@ -2260,10 +3847,6 @@ export var NodeShape;
             !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
             return false;
         }
-        if (filter.name !== undefined &&
-            !$filterMaybe($filterString)(filter.name, value.name)) {
-            return false;
-        }
         if (filter.nodeKind !== undefined &&
             !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
             return false;
@@ -2277,7 +3860,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 &&
@@ -2292,6 +3875,14 @@ export var NodeShape;
             !$filterMaybe($filterIri)(filter.rdfType, value.rdfType)) {
             return false;
         }
+        if (filter.shaclmateName !== undefined &&
+            !$filterMaybe($filterString)(filter.shaclmateName, value.shaclmateName)) {
+            return false;
+        }
+        if (filter.subClassOf !== undefined &&
+            !$filterArray($filterIri)(filter.subClassOf, value.subClassOf)) {
+            return false;
+        }
         if (filter.toRdfTypes !== undefined &&
             !$filterArray($filterIri)(filter.toRdfTypes, value.toRdfTypes)) {
             return false;
@@ -2312,8 +3903,12 @@ export var NodeShape;
             !$filterMaybe($filterIri)(filter.tsObjectDeclarationType, value.tsObjectDeclarationType)) {
             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;
@@ -2397,12 +3992,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,
@@ -2431,17 +4027,19 @@ 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,
@@ -2661,19 +4259,21 @@ 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({
+                .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(),
+                })),
+        }).chain((label) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema.properties.languageIn,
@@ -2879,27 +4479,6 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((mutable) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.$schema
-                .properties
-                .name,
-            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
-                        .name
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((name) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema
@@ -2982,16 +4561,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,
@@ -3050,6 +4631,45 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((rdfType) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .shaclmateName,
+            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
+                        .shaclmateName
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((shaclmateName) => $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
@@ -3168,6 +4788,24 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((tsObjectDeclarationType) => $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
@@ -3187,16 +4825,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
-                    .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,
@@ -3204,7 +4844,7 @@ export var NodeShape;
             and,
             classes,
             closed,
-            comments,
+            comment,
             datatype,
             deactivated,
             discriminantValue,
@@ -3216,7 +4856,7 @@ export var NodeShape;
             ignoredProperties,
             in_,
             isDefinedBy,
-            labels,
+            label,
             languageIn,
             maxCount,
             maxExclusive,
@@ -3227,7 +4867,6 @@ export var NodeShape;
             minInclusive,
             minLength,
             mutable,
-            name,
             nodeKind,
             nodes,
             not,
@@ -3235,13 +4874,16 @@ export var NodeShape;
             patterns,
             properties,
             rdfType,
+            shaclmateName,
+            subClassOf,
             toRdfTypes,
             tsFeatureExcludes,
             tsFeatureIncludes,
             tsImports,
             tsObjectDeclarationType,
+            types,
             xone,
-        })))))))))))))))))))))))))))))))))))))))))))));
+        })))))))))))))))))))))))))))))))))))))))))))))));
     };
     NodeShape.$schema = {
         properties: {
@@ -3267,7 +4909,7 @@ export var NodeShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3291,10 +4933,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"),
@@ -3400,10 +5042,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"),
@@ -3491,14 +5133,6 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
             },
-            name: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
-            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -3536,7 +5170,7 @@ export var NodeShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3568,6 +5202,22 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
             },
+            shaclmateName: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+            },
+            subClassOf: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Set",
+                    item: () => ({ kind: "Iri" }),
+                }),
+                path: $RdfVocabularies.rdfs.subClassOf,
+            },
             toRdfTypes: {
                 kind: "Shacl",
                 type: () => ({
@@ -3642,10 +5292,18 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"),
             },
-            xone: {
+            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" }),
@@ -3667,9 +5325,9 @@ export var NodeShape;
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), 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;
                     }
@@ -3695,7 +5353,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()
@@ -3759,7 +5419,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) => {
@@ -3811,15 +5473,12 @@ export var NodeShape;
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
-        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), _nodeShape.name
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _nodeShape.nodeKind.toList(), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.nodes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _nodeShape.not.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        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;
                     }
@@ -3842,14 +5501,19 @@ export var NodeShape;
         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://purl.org/shaclmate/ontology#rdfType"), _nodeShape.rdfType.toList(), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"), _nodeShape.shaclmateName
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        resource.add($RdfVocabularies.rdfs.subClassOf, _nodeShape.subClassOf.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"), _nodeShape.toRdfTypes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), _nodeShape.tsFeatureExcludes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), _nodeShape.tsFeatureIncludes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), _nodeShape.tsImports.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsObjectDeclarationType"), _nodeShape.tsObjectDeclarationType.toList(), 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.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;
                     }
@@ -3875,15 +5539,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)) {
@@ -3950,7 +5605,7 @@ export var Shape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3966,10 +5621,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"),
@@ -4025,10 +5680,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"),
@@ -4116,14 +5771,6 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
             },
-            name: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
-            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -4161,7 +5808,7 @@ export var Shape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -4177,10 +5824,18 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
             },
+            shaclmateName: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+            },
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -4190,6 +5845,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 [
@@ -4216,21 +5880,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)) {
@@ -4337,16 +5986,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 [
@@ -4609,7 +6281,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) {
@@ -4633,11 +6305,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,
                 })) {
@@ -4669,7 +6341,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 });
@@ -4684,13 +6356,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) {
@@ -4702,7 +6374,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) {
@@ -4726,18 +6398,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 });
                         }
                     }
                 }
@@ -4764,11 +6436,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;
@@ -4782,18 +6454,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;
                         }
                     }
@@ -4803,10 +6475,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) {