@shaclmate/compiler 4.0.14 → 4.0.16

package/dist/input/generated.js

@@ -1,7 +1,8 @@
 import dataFactory from "@rdfjs/data-model";
 import datasetFactory from "@rdfjs/dataset";
+import { LiteralFactory } from "@rdfx/literal";
+import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
 import { Either, Left, Maybe, Right } from "purify-ts";
-import { LiteralFactory, PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "rdfjs-resource";
 function $filterArray(filterItem) {
     return (filter, values) => {
         for (const value of values) {
@@ -162,6 +163,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,291 +235,924 @@ 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.comment !== undefined &&
-            !$filterMaybe($filterString)(filter.comment, value.comment)) {
-            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.description !== undefined &&
-            !$filterMaybe($filterString)(filter.description, value.description)) {
-            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.label !== undefined &&
-            !$filterMaybe($filterString)(filter.label, value.label)) {
-            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.nodeKind !== undefined &&
-            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
-            return false;
+        else {
+            deactivated = parameters.deactivated;
         }
-        if (filter.nodes !== undefined &&
-            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
-            return false;
+        let defaultValue;
+        if (Maybe.isMaybe(parameters.defaultValue)) {
+            defaultValue = parameters.defaultValue;
         }
-        if (filter.not !== undefined &&
-            !$filterArray($filterIdentifier)(filter.not, value.not)) {
-            return false;
+        else if (typeof parameters.defaultValue === "bigint") {
+            defaultValue = Maybe.of($literalFactory.bigint(parameters.defaultValue));
         }
-        if (filter.or !== undefined &&
-            !$filterArray($filterArray($filterIdentifier))(filter.or, value.or)) {
-            return false;
+        else if (typeof parameters.defaultValue === "boolean") {
+            defaultValue = Maybe.of($literalFactory.boolean(parameters.defaultValue));
         }
-        if (filter.order !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
-            return false;
+        else if (typeof parameters.defaultValue === "object" &&
+            parameters.defaultValue instanceof Date) {
+            defaultValue = Maybe.of($literalFactory.date(parameters.defaultValue));
         }
-        if (filter.path !== undefined &&
-            !$PropertyPath.$filter(filter.path, value.path)) {
-            return false;
+        else if (typeof parameters.defaultValue === "number") {
+            defaultValue = Maybe.of($literalFactory.number(parameters.defaultValue));
         }
-        if (filter.patterns !== undefined &&
-            !$filterArray($filterString)(filter.patterns, value.patterns)) {
-            return false;
+        else if (typeof parameters.defaultValue === "string") {
+            defaultValue = Maybe.of($literalFactory.string(parameters.defaultValue));
         }
-        if (filter.resolve !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.resolve, value.resolve)) {
-            return false;
+        else if (typeof parameters.defaultValue === "object") {
+            defaultValue = Maybe.of(parameters.defaultValue);
         }
-        if (filter.shaclmateName !== undefined &&
-            !$filterMaybe($filterString)(filter.shaclmateName, value.shaclmateName)) {
-            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.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,
+        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) => {
@@ -956,16 +1605,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,
@@ -1129,16 +1780,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
-                    .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,
@@ -1196,7 +1849,7 @@ export var PropertyShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1431,7 +2084,7 @@ export var PropertyShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1502,7 +2155,7 @@ export var PropertyShape;
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -1519,9 +2172,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;
                     }
@@ -1641,9 +2294,9 @@ export var PropertyShape;
         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;
                     }
@@ -1685,9 +2338,9 @@ export var PropertyShape;
             $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;
                     }
@@ -1709,15 +2362,319 @@ export var PropertyShape;
         ]), options?.graph);
         return resource;
     }
-    PropertyShape.$toRdfResource = $toRdfResource;
-})(PropertyShape || (PropertyShape = {}));
-export var PropertyGroup;
-(function (PropertyGroup) {
+    PropertyShape.$toRdfResource = $toRdfResource;
+})(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
+        $Identifier.toString = Resource.Identifier.toString;
+    })($Identifier = PropertyGroup.$Identifier || (PropertyGroup.$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;
+        }
+        return true;
+    }
+    PropertyGroup.$filter = $filter;
+    PropertyGroup.$fromRdfResource = (resource, options) => {
+        let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
+        }
+        return PropertyGroup.$propertiesFromRdfResource(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            objectSet,
+            preferredLanguages,
+        });
+    };
+    PropertyGroup.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyGroup.$fromRdfResource(resource, options))));
+    PropertyGroup.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
+    function isPropertyGroup(object) {
+        switch (object.$type) {
+            case "PropertyGroup":
+                return true;
+            default:
+                return false;
+        }
+    }
+    PropertyGroup.isPropertyGroup = isPropertyGroup;
+    PropertyGroup.$propertiesFromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => {
+                // Check the expected type and its known subtypes
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/ns/shacl#PropertyGroup":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(PropertyGroup.$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#PropertyGroup)`));
+            })
+            : 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("PropertyGroup").chain(($type) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            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 = PropertyGroup.$Identifier || (PropertyGroup.$Identifier = {}));
+    })($Identifier = Ontology.$Identifier || (Ontology.$Identifier = {}));
     function $filter(filter, value) {
         if (filter.$identifier !== undefined &&
             !$filterIdentifier(filter.$identifier, value.$identifier)) {
@@ -1731,15 +2688,31 @@ export var PropertyGroup;
             !$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;
     }
-    PropertyGroup.$filter = $filter;
-    PropertyGroup.$fromRdfResource = (resource, options) => {
+    Ontology.$filter = $filter;
+    Ontology.$fromRdfResource = (resource, options) => {
         let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
         if (!objectSet) {
             objectSet = new $RdfjsDatasetObjectSet(resource.dataset);
         }
-        return PropertyGroup.$propertiesFromRdfResource(resource, {
+        return Ontology.$propertiesFromRdfResource(resource, {
             context,
             graph,
             ignoreRdfType,
@@ -1747,20 +2720,20 @@ export var PropertyGroup;
             preferredLanguages,
         });
     };
-    PropertyGroup.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+    Ontology.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
         .toResource()
-        .chain((resource) => PropertyGroup.$fromRdfResource(resource, options))));
-    PropertyGroup.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
-    function isPropertyGroup(object) {
+        .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 "PropertyGroup":
+            case "Ontology":
                 return true;
             default:
                 return false;
         }
     }
-    PropertyGroup.isPropertyGroup = isPropertyGroup;
-    PropertyGroup.$propertiesFromRdfResource = ($resource, _$options) => {
+    Ontology.isOntology = isOntology;
+    Ontology.$propertiesFromRdfResource = ($resource, _$options) => {
         return (!_$options.ignoreRdfType
             ? $resource
                 .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
@@ -1768,16 +2741,16 @@ export var PropertyGroup;
                 .chain((actualRdfType) => {
                 // Check the expected type and its known subtypes
                 switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#PropertyGroup":
+                    case "http://www.w3.org/2002/07/owl#Ontology":
                         return Right(true);
                 }
                 // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(PropertyGroup.$fromRdfType, {
+                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/ns/shacl#PropertyGroup)`));
+                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,
@@ -1787,10 +2760,10 @@ export var PropertyGroup;
         }).toValues())
             .chain((values) => values.chainMap((value) => value.toIdentifier()))
             .chain((values) => values.head())
-            .chain(($identifier) => Right("PropertyGroup").chain(($type) => $shaclPropertyFromRdf({
+            .chain(($identifier) => Right("Ontology").chain(($type) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyGroup.$schema.properties.comment,
+            propertySchema: Ontology.$schema.properties.comment,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
@@ -1804,7 +2777,7 @@ export var PropertyGroup;
         }).chain((comment) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyGroup.$schema.properties.label,
+            propertySchema: Ontology.$schema.properties.label,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toString()))
@@ -1815,9 +2788,95 @@ export var PropertyGroup;
                     propertyPath: PropertyShape.$schema.properties.label.path,
                     value: Maybe.empty(),
                 })),
-        }).map((label) => ({ $identifier, $type, comment, label }))))));
+        }).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: 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) => ({
+            $identifier,
+            $type,
+            comment,
+            label,
+            tsFeatureExcludes,
+            tsFeatureIncludes,
+            tsImports,
+            tsObjectDeclarationType,
+        }))))))))));
     };
-    PropertyGroup.$schema = {
+    Ontology.$schema = {
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -1827,372 +2886,850 @@ export var PropertyGroup;
                 kind: "Discriminant",
                 type: () => ({
                     kind: "TypeDiscriminant",
-                    ownValues: ["PropertyGroup"],
+                    ownValues: ["Ontology"],
+                }),
+            },
+            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"),
+            },
+            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"),
             },
-            comment: {
+            tsImports: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Maybe",
+                    kind: "Set",
                     item: () => ({ kind: "String" }),
                 }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
             },
-            label: {
+            tsObjectDeclarationType: {
                 kind: "Shacl",
                 type: () => ({
                     kind: "Maybe",
-                    item: () => ({ kind: "String" }),
+                    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://www.w3.org/2000/01/rdf-schema#label"),
+                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)));
+        }
+        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 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;
         }
-        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) {
-    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;
+        let shaclmateName;
+        if (Maybe.isMaybe(parameters?.shaclmateName)) {
+            shaclmateName = parameters?.shaclmateName;
         }
-        if (filter.comment !== undefined &&
-            !$filterMaybe($filterString)(filter.comment, value.comment)) {
-            return false;
+        else if (typeof parameters?.shaclmateName === "string") {
+            shaclmateName = Maybe.of(parameters?.shaclmateName);
         }
-        if (filter.label !== undefined &&
-            !$filterMaybe($filterString)(filter.label, value.label)) {
-            return false;
+        else if (parameters?.shaclmateName === undefined) {
+            shaclmateName = Maybe.empty();
         }
-        if (filter.tsFeatureExcludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureExcludes, value.tsFeatureExcludes)) {
-            return false;
+        else {
+            shaclmateName = parameters?.shaclmateName;
         }
-        if (filter.tsFeatureIncludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureIncludes, value.tsFeatureIncludes)) {
-            return false;
+        let subClassOf;
+        if (parameters?.subClassOf === undefined) {
+            subClassOf = [];
         }
-        if (filter.tsImports !== undefined &&
-            !$filterArray($filterString)(filter.tsImports, value.tsImports)) {
-            return false;
+        else if ($isReadonlyObjectArray(parameters?.subClassOf)) {
+            subClassOf = parameters?.subClassOf;
         }
-        if (filter.tsObjectDeclarationType !== undefined &&
-            !$filterMaybe($filterIri)(filter.tsObjectDeclarationType, value.tsObjectDeclarationType)) {
-            return false;
+        else if ($isReadonlyStringArray(parameters?.subClassOf)) {
+            subClassOf = parameters?.subClassOf.map((item) => dataFactory.namedNode(item));
         }
-        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 {
+            subClassOf = parameters?.subClassOf;
         }
-        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;
+        let toRdfTypes;
+        if (parameters?.toRdfTypes === undefined) {
+            toRdfTypes = [];
         }
-    }
-    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: 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 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,
+            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"],
-                }),
-            },
-            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"),
-            },
-            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#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;
+            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
@@ -2208,7 +3745,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 &&
@@ -2324,7 +3861,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 &&
@@ -2343,6 +3880,10 @@ export var NodeShape;
             !$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;
@@ -2363,8 +3904,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;
@@ -2448,12 +3993,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,
@@ -3016,16 +4562,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,
@@ -3105,6 +4653,24 @@ export var NodeShape;
                     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
@@ -3223,6 +4789,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
@@ -3242,16 +4826,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,
@@ -3290,13 +4876,15 @@ export var NodeShape;
             properties,
             rdfType,
             shaclmateName,
+            subClassOf,
             toRdfTypes,
             tsFeatureExcludes,
             tsFeatureIncludes,
             tsImports,
             tsObjectDeclarationType,
+            types,
             xone,
-        })))))))))))))))))))))))))))))))))))))))))))));
+        })))))))))))))))))))))))))))))))))))))))))))))));
     };
     NodeShape.$schema = {
         properties: {
@@ -3322,7 +4910,7 @@ export var NodeShape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3583,7 +5171,7 @@ export var NodeShape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -3623,6 +5211,14 @@ export var NodeShape;
                 }),
                 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: () => ({
@@ -3697,10 +5293,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" }),
@@ -3722,9 +5326,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;
                     }
@@ -3873,9 +5477,9 @@ export var NodeShape;
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _nodeShape.nodeKind.toList(), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.nodes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _nodeShape.not.flatMap((item) => [item]), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.flatMap((item) => [
-            item.length > 0
-                ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
                         currentSubListResource = listResource;
                     }
@@ -3901,14 +5505,16 @@ export var NodeShape;
         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;
                     }
@@ -4000,7 +5606,7 @@ export var Shape;
             and: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -4203,7 +5809,7 @@ export var Shape;
             or: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),
@@ -4230,7 +5836,7 @@ export var Shape;
             xone: {
                 kind: "Shacl",
                 type: () => ({
-                    kind: "Set",
+                    kind: "Maybe",
                     item: () => ({
                         kind: "List",
                         item: () => ({ kind: "Identifier" }),